Synnefo » Pithos

/*

 * Copyright 2007, 2008, 2009 Electronic Business Systems Ltd.

 *

 * This file is part of GSS.

 *

 * GSS is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * GSS is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with GSS.  If not, see <http://www.gnu.org/licenses/>.

 */

package gr.ebs.gss.server.domain;

import java.io.Serializable;

import java.util.Date;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.Id;

import javax.persistence.JoinColumn;

import javax.persistence.ManyToOne;

import javax.persistence.Temporal;

import javax.persistence.TemporalType;

/**

 * This class holds information about bandwidth usage by users.

 * This information is broken down in time periods.

 */

@Entity

public class AccountingInfo  implements Serializable{

	/**

	 * The persistence ID of the object.

	 */

	@SuppressWarnings("unused")

	@Id

	@GeneratedValue

	private Long id;

	/**

	 * The user whose usage we are noting. We can never change it after

	 * creation.

	 */

	@ManyToOne

	@JoinColumn(updatable = false, nullable = false)

	private User user;

	/**

	 * The start of the time period. We can never change it after

	 * creation.

	 */

	@Temporal(TemporalType.TIMESTAMP)

	@Column(updatable = false, nullable = false)

	private Date dateFrom;

	/**

	 * The end of the time period. We can never change it after

	 * creation.

	 */

	@Temporal(TemporalType.TIMESTAMP)

	@Column(updatable = false, nullable = false)

	private Date dateTo;

	/**

	 * The usage itself, in bytes.

	 */

	@Column(nullable = false)

	private long bandwidthUsed = 0;

	/**

	 * Default constructor. Required by Hibernate,

	 * but shouldn't be called.

	 */

	@SuppressWarnings("unused")

	private AccountingInfo() {

	}

	/**

	 * Constructor

	 */

	public AccountingInfo(User _user, Date _dateFrom, Date _dateTo) {

		user = _user;

		dateFrom = _dateFrom;

		dateTo = _dateTo;

	}

	/**

	 * Retrieve the user

	 * @return the user

	 */

	public User getUser() {

		return user;

	}

	/**

	 * Retrieve the start of the time period.

	 * @return the start of the time period

	 */

	public Date getDateFrom() {

		return dateFrom;

	}

	/**

	 * Retrieve the end of the time period.

	 * @return the end of the time period

	 */

	public Date getDateTo() {

		return dateTo;

	}

	/**

	 * Retrieve the bandwidth used.

	 * @return the bandwidth used

	 */

	public long getBandwidthUsed() {

		return bandwidthUsed;

	}

	/**

	 * Update bandwidth used upwards or downwards with new amount.

	 * @param bandwidthDiff The amount by which to update;

	 * positive for increase, negative for decrease.

	 */

	public void updateBandwidth(long bandwidthDiff) {

		bandwidthUsed += bandwidthDiff;

	}

}

	 * @return The FileHeaderDTO created

	public FileHeaderDTO createFile(Long userId, Long folderId, String name, String mimeType,

	 * @return The FileHeaderDTO created

	public FileHeaderDTO updateFileContents(Long userId, Long fileId, String mimeType,

	 * @return The FileHeaderDTO created

	public FileHeaderDTO createFile(Long userId, Long folderId, String name, String mimeType, File uploadedFile)

	 * @return The FileHeaderDTO updated

	public FileHeaderDTO updateFileContents(Long userId, Long fileId, String mimeType,

	/**

	 * Update accounting information for given user.

	 *

	 * @param user The user to update

	 * @param date Date of transaction

	 * @param bandwidthDiff Bandwidth used; positive for addition,

	 * negative for subtraction (e.g. to rollback)

	 */

	public void updateAccounting(User user, Date date, long bandwidthDiff);

	public FileHeaderDTO createFile(Long userId, Long folderId, String name, String mimeType, InputStream stream)

		return createFile(userId, folderId, name, mimeType, file);

	public FileHeaderDTO updateFileContents(Long userId, Long fileId, String mimeType, InputStream resourceInputStream) throws ObjectNotFoundException, GSSIOException, InsufficientPermissionsException, QuotaExceededException {

		return updateFileContents(userId, fileId, mimeType, file);

	public FileHeaderDTO createFile(Long userId, Long folderId, String name, String mimeType, File fileObject)

		return file.getDTO();

	public FileHeaderDTO updateFileContents(Long userId, Long fileId, String mimeType, File fileObject) throws ObjectNotFoundException, GSSIOException, InsufficientPermissionsException, QuotaExceededException {

		return file.getDTO();

		body.setMimeType(mimeType);

	@Override

	public void updateAccounting(User user, Date date, long bandwidthDiff) {

		dao.updateAccounting(user, date, bandwidthDiff);

	}

	 * @return The FileHeaderDTO created

	public FileHeaderDTO createFile(Long userId, Long folderId, String name, String mimeType, InputStream stream) throws DuplicateNameException, ObjectNotFoundException, GSSIOException, InsufficientPermissionsException, QuotaExceededException;

	 * @return The FileHeaderDTO updated

	public FileHeaderDTO updateFileContents(Long userId, Long fileId, String mimeType, InputStream resourceInputStream) throws ObjectNotFoundException, GSSIOException, InsufficientPermissionsException, QuotaExceededException;

import java.util.Date;

	/**

	 * Update accounting info for given user.

	 * Adds bandwidth used to appropriate time period bucket.

	 * Bucket is created if needed.

	 *

	 * @param user The user to update

	 * @param date Date of transaction

	 * @param bandwidthDiff Bandwidth used; positive for addition,

	 * negative for subtraction (e.g. to rollback)

	 */

	public void updateAccounting(User user, Date date, long bandwidthDiff);

import gr.ebs.gss.server.domain.AccountingInfo;

import java.util.Calendar;

import java.util.Date;

import java.util.GregorianCalendar;

	private static final int BANDWIDTH_TIME_PERIOD_FIELD = Calendar.MONTH;

	private static final int BANDWIDTH_TIME_PERIOD_AMOUNT = 1;

	@Override

	public void updateAccounting(User user, Date date, long bandwidthDiff) {

		AccountingInfo ai = null;

		try {

			ai = (AccountingInfo) manager.createQuery("select ai from AccountingInfo ai " +

				"where ai.user=:user and ai.dateFrom<=:date and ai.dateTo>:date")

				.setParameter("user", user)

				.setParameter("date", date)

				.getSingleResult();

		}

		catch (NoResultException e) {

			ai = null;

		}

		if (ai==null) {

			// The right entry does not exist; must be created.

			// This is where we set the initial time period.

			// We now start from the user's creation, we can change this to something else.

			Calendar creationDate = new GregorianCalendar();

			creationDate.setTime(user.getAuditInfo().getCreationDate());

			int offset = 0;

			Calendar dateFrom;

			Calendar dateTo;

			long timeInMillis = date.getTime();

			do {

				dateFrom = (Calendar) creationDate.clone();

				dateFrom.add(BANDWIDTH_TIME_PERIOD_FIELD, offset);

				dateTo = (Calendar) dateFrom.clone();

				dateTo.add(BANDWIDTH_TIME_PERIOD_FIELD, 1);

				offset += BANDWIDTH_TIME_PERIOD_AMOUNT;

			}

			while (!(dateFrom.getTimeInMillis()<=timeInMillis && dateTo.getTimeInMillis()>timeInMillis));

			ai = new AccountingInfo(user, dateFrom.getTime(), dateTo.getTime());

			manager.persist(ai);

		}

		// Do the update.

		ai.updateBandwidth(bandwidthDiff);

	}

import java.util.Date;

	    			if (file!=null) getService().updateAccounting(user, new Date(), contentLength);

	    				getService().updateAccounting(user, new Date(), contentLength);

	    				getService().updateAccounting(user, new Date(), contentLength);

					FileHeaderDTO fileDTO = null;

						fileDTO = getService().createFile(user.getId(), folder.getId(), fileName, contentType, uploadedFile);

						fileDTO = getService().updateFileContents(user.getId(), file.getId(), contentType, uploadedFile);

					getService().updateAccounting(user, new Date(), fileDTO.getFileSize());

        	FileHeaderDTO fileDTO = null;

            	fileDTO = getService().updateFileContents(user.getId(), file.getId(), mimeType, resourceInputStream);

				fileDTO = getService().createFile(user.getId(), folder.getId(), name, mimeType, resourceInputStream);

            getService().updateAccounting(user, new Date(), fileDTO.getFileSize());

import java.util.Date;

			FileHeaderDTO file = api.createFile(userId, folderId, name, mimeType, stream.getInputStream());

			User user = api.getUser(userId);

			api.updateAccounting(user, new Date(), file.getFileSize());

			FileHeaderDTO file = api.updateFileContents(userId, fileId, mimeType, resourceInputStream.getInputStream());

			User user = api.getUser(userId);

			api.updateAccounting(user, new Date(), file.getFileSize());

			FileHeaderDTO fileDTO = null;

				fileDTO = getService().updateFileContents(user.getId(), file.getId(), mimeType, resourceInputStream);

				fileDTO = getService().createFile(user.getId(), folder.getId(), name, mimeType, resourceInputStream);

			getService().updateAccounting(user, new Date(), fileDTO.getFileSize());

				getService().updateAccounting(user, new Date(), contentLength);

					getService().updateAccounting(user, new Date(), contentLength);