I am a graduate student at Northeastern University pursuing MS in Telecommunication Networks. I have a growing interest in data networking, Cloud Computing, Linux, wireless communications, and telecommunications.
Since childhood, I am passionate about computer networks and communications. This passion carried me through my education at Rajasthan Technical University, and I did the under graduation in Electronics and Communications. During my undergrad, I developed a keen understanding of wireless communication, cloud computing, and antennas that drove me to a master's degree in digital communications. There I found ample resources to enrich my learnings. I studied many new things and implemented them practically with the same fascination that drove me as a kid.
I have a strong background in telecommunication antennas and other wireless communication research areas. I also have a broad skillset in many technical areas.
My specialties also include quick learning, Problem-solving, leadership, and working in a team. As I go forward, I will continue to upgrade my knowledge, as many questions are unsolved yet, and I am on my way to solve them.
I worked as a Research Assistant in the Digital Communications lab at Jagannath University, Jaipur, India. During this period, I was predominantly working on many research projects. My job duties and responsibilities were:
Accumulate results obtained from various experiments.
Address the issues in the field of research to other members.
Assist professors in writing project proposals.
Perform all the necessary follow-up tasks.
I was under the team of Operation and Maintenance of the Telecommunication System at GAIL (India) Limited, Jaipur, India. I worked in the troubleshooting problem section, where I dealt with video conferencing problems, optical fiber communication, and customer support handling.
GPA: 4.00
CGPA: 7.4
Percentage: 75%
Please compose your message below:


BOAST
BOAST is a server built to receive and report Out-of-Band Application Security Testing interactions.
BOAST features DNS, HTTP, and HTTPS protocol receivers with support for multiple simultaneous ports for each
receiver.
Requests made to BOAST by the target web application can be viewed in the OAST Callbacks
Tab in the ZAP GUI.
Scripts
If the Script Console and the GraalVM JavaScript add-ons are installed, a new script called
"OAST Get BOAST Servers.js" is added to ZAP. This script prints all the available information related to the registered
BOAST servers. The primary purpose of this script is to demonstrate how to interact with BOAST from a script. This will
enable you to write other scripts that make use of BOAST payloads and canary values to perform out-of-band attacks.
See also


Author: Carl Nagle Since: FEB 24, 2012 Updated: FEB 27, 2012 Carl Nagle, org.safs.android.messenger.client info Copyright SAS Institute, Inc: http://www.sas.com General Public License (GPL): http://www.opensource.org/licenses/gpl-license.php
The SAFS TCP Messenger Service for Android is an Android application that provides general-purpose TCP messaging services between remote clients and installed Android applications that DO NOT have Android INTERNET permissions.
For example, Android test applications testing Android application that do not have INTERNET permissions are themselves not allowed to have INTERNET permissions. By using the SAFS TCP Messenger Service the test application can communicate with a remote test controller, receive external commands via TCP sockets, and return test results or data to the remote controller.
The initial uses for this SAFS TCP Messenger Service are to provide for Robotium Remote Control and SAFS Android Remote Control using the SAFS Automation Framework. However, the general-purpose nature of the SAFS TCP Messenger Service makes it suitable for other uses on Android independent of these test automation solutions.
Upon release, an independent SAFS TCP Messenger will be available from the SAFS Downloads Page.
The SAFS TCP Messenger will also be bundled as part of a future Robotium Remote Control download, and/or a future SAFS Android Support download.
Inside SAFSTCPMessenger.ZIP:
The general-purpose Android Application Service ready to be installed on the Android device or Emulator.
This application is signed with the Android SDK's default debug certificate.
If you need this APK to be signed with a different certificate, then you or another Android developer can explode the APK and resign with your desired certificate using the Android SDK tools.
Install the SAFS TCP Messenger application from the Android Market(future), or from your local Android development environment or network repository. A typical command-line install using the Android SDK tools would be:
adb install <pathTo>\SAFSTCPMessenger-debug.apk
This Java library provides the org.safs.sockets Java classes used by both:
(Normally these two are coordinated efforts since both sides have to interpret the messaging.)
The JAR file must be in the Android project's /libs directory for the Ant build to see, and/or otherwise referenced as a developer's Java Build Path dependency for remote TCP client development.
This Java library provides the MessageUtil Java class used by:
The JAR file must be in the Android project's /libs directory for the Ant build to see.
Generally, developers wishing to create a remote TCP client simply have to implement a CommandListener interface listening to an instance of a MessengerRunner.
Developers provide their own message content and syntax to be transported over the predefined SocketProtocol. This content will ultimately be received by the SAFS TCP Messenger and forwarded to the Android application. So the Android application must be coded to understand the content, know how to parse it, and know what the remote client might be expecting in return.
The SAFS TCP Messenger doesn't care about the message syntax as long as the content conforms to being transported over the SocketProtocol.
The Android application must will have the following Java library dependencies previously mentioned. These will reside in the Android project's /libs directory:
The Android application will generally launch the SAFS TCP Messenger during it's onCreate
method to insure the Service is available when the application is launched. The application will bind with the Service--usually with an instance of a MessengerRunner as shown below.
import org.safs.android.messenger.MessageUtil;
import org.safs.android.messenger.client.CommandListener;
import org.safs.android.messenger.client.MessengerRunner;
import org.safs.android.messenger.client.MessageResult;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
public class YourAppClass extends <YourAppSuperclass> implements CommandListener{
public void onCreate(Bundle savedInstanceState){
if(!doBindService()){
return;
}
start();
}
ServiceConnection mConnection = new ServiceConnection(){
public void onServiceConnected(ComponentName className, IBinder service){
Messenger mService = new Messenger(service);
if(messageRunner==null){
messageRunner = new MessengerRunner(mService, this);
messageRunner.start();
messageRunner.sendRegisterEngine();
}
}
public void onServiceDisconnected(ComponentName className){
if(messageRunner != null){
messageRunner.sendUnRegisterEngine();
messageRunner = null;
}
}
};
boolean mIsBound = false;
protected boolean doBindService(){
try{
mIsBound = getContext().bindService(new Intent(MessageUtil.SERVICE_CONNECT_INTENT), mConnection, Context.BIND_AUTO_CREATE);
return mIsBound;
}catch(Exception x){
return false;
}
}
}
// implement your CommandListener interface below
Then, if your CommandListener needs to respond to any incoming message it can do so with the methods already available from the MessengerRunner:
messageRunner.sendReady(); messageRunner.sendRunning(); messageRunner.sendServiceResult(java.util.Properties); messageRunner.sendServiceResult(int,java.lang.String); messageRunner.sendMessage(java.lang.String); messageRunner.sendException(java.lang.String); messageRunner.sendDebug(java.lang.String); messageRunner.sendShutdown();
The Android SDK provides examples of implementing Android Messaging with Android services. Our implementations for both Robotium Remote Control and SAFS Remote Control also serve as real-world examples of using the SAFS TCP Messenger Service specifically.
The Android application will ultimately be communicating with the SAFS TCP Messenger using the Inter-Process Communication (IPC) protocols provided by the Android OS.


Definition at line 1130 of file gtest-port.h.
Referenced by testing::Message::GetString(), and testing::AssertionResult::operator!().


void StpCallback_OnTopologyChange ( const struct STP_BRIDGE* bridge, unsigned int treeIndex, unsigned int timestamp );
Application-defined function that is called by the STP library when it detects a change in the network topology on the local bridge.
This callback allows the application to implement the following:
The library calls this callback only as long as the bridge is running at least RSTP (see STP_CreateBridge, STP_SetStpVersion). The detection of topology changes in LegacySTP mode (as per <IP_ADDRESS> in 802.1D-1998) is not yet implemented.
The STP library calls this callback when it detects a topology change on the local bridge (i.e., a non-edge port transitioning to/from the forwarding state while the bridge is not isolated).
StpCallback_OnTopologyChange is a placeholder name used throughout this documentation. The application may name this callback differently.


Home
30 Minutes to a Data Enabled Web Form
Name:
My Location - Latitude
My Location - Longitude
Share Location
My experience with MongoDB:
Brand new to MongoDB
Played with it
Used in the past
My company uses it
Advanced MongoDB User
I am a:
Database Administrator
Developer/Engineer
Developer Advocate/Relations
DevOps/SRE
Data Analyst/Scientist
Other
Send Response


This page will contain movies people have made.
click here to access the prototype demo without a query ID
Click here to access the movie creation page


About
Enlighten Designs is an Internet solutions provider that specialises in front and back end development. To view some of the web sites we have created view our portfolio.
We are currently undergoing a 'face lift', so if you have any questions or would like more information about the services we provide please feel free to contact us.
Contact Us
Phone: (07) 853 6060
Fax: (07) 853 6060
Email<EMAIL_ADDRESS>P.O Box: 14159, Hamilton, New Zealand


--- layout: default ---
UYU has recently made a change to their roster. Due to this, they do not have an updated team photo at the moment.
| Name: | Anthony "Methodz" Zinni | Mehran "Mayhem" Anjomshoa | Matteo "Royalty" Faithfull | Nick "Proto" Maldonado | Saul "Parzelion" Masse | Alex "Zaptius" Bonilla |
| Born: | August 15, 1997 | November 28, 1997 | Unknown | September 26, 1998 | October 24, 1998 | Unknown |
| From: | United States | Canada | Canada | United States | United States | United States |
| Role | Main AR | AR Slayer | SMG Slayer | SMG Slayer | Main AR | Substitute |


Select which students/learning groups can enroll the #{msg['label.credential'].toLowerCase()} #{msg['label.delivery'].toLowerCase()}:
Enrollment open to all units having access to the #{msg['label.credential'].toLowerCase()}
Save changes
Since there is at least one learning group removed from the #{msg['label.delivery'].toLowerCase()}, please choose how the removal will affect the #{msg['label.instructor.plural'].toLowerCase()} from these learning groups:
The #{msg['label.instructor.plural'].toLowerCase()} can complete not submitted assessments and students can be assigned to them in this #{msg['label.credential'].toLowerCase()} #{msg['label.delivery'].toLowerCase()}.
The #{msg['label.instructor.plural'].toLowerCase()} can complete not submitted assessments, but no more students can be assigned to them in this #{msg['label.credential'].toLowerCase()} #{msg['label.delivery'].toLowerCase()} (the #{msg['label.instructor'].toLowerCase()} will be marked as inactive).
The #{msg['label.instructor.plural'].toLowerCase()} will be withdrawn from all not submitted assessments, and no more students can be assigned to them in this #{msg['label.credential'].toLowerCase()} #{msg['label.delivery'].toLowerCase()} (the #{msg['label.instructor'].toLowerCase()} will be marked as inactive).


List of most recent events. Events are not clickable yet. A primary event is displayed on the main page.


CrimPapers
Articles published on 27 February 2020
On 27 February 2020, 7 new articles were published in 7 journals.
Does Size Influence Jail Efficiency? An Analysis of Local Jails in the United States by Erik Alda
Is Resilience A Favourable Concept in Terrorism Research? the Multifaceted Discourses of Resilience in the Academic Literature by S. H. Jore
Social Opportunities and Controls: Revisiting the Desistance Effect of Employment by David Abeling-Judge
A Home Is More Than A Roof Over Your Head: Post-Prison Reintegration Challenges in Austria by Doris Schartmueller
Death in Dallas: Sentencing Patterns of Pre-Furman Capital Offenders by Sarah A. El Sayed, Denise Paquette Boots, James W. Marquart, Stephanie M. Sanford
Review of Drugs: Phase One Report by HM Government
Self-Compassionate Responses to An Imagined Sexual Assault by Ashley Batts Allen, Stephanie Cazeau, Jodi Grace, Ashley Stefano Banos


index
|
up
|
prev
|
next
ConcreteSymbolCreator<SymbolT> Class
Definition at line
877
of
Symbol.cpp
Member Functions
Symbol
*
CreateSymbol
(
const
Span
& span,
const
std::u32string& name)
override
Member Function Details
CreateSymbol Member Function
Symbol
* cmajor::symbols::ConcreteSymbolCreator::CreateSymbol(
const
Span
& span,
const
std::u32string& name)
override
Definition at line
880
of
Symbol.cpp
:
881
{
882
return
new
SymbolT
(
span
,
name
)
;
883
}
Base class overridden functions:
cmajor::symbols::SymbolCreator::CreateSymbol
index
|
up
|
prev
|
next


Interface ICsMember
Base definition for all c# member models.
Inherited Members
Namespace: CodeFactory.DotNet.CSharp
Assembly: CodeFactory.DotNet.dll
Syntax
public interface ICsMember : ICsModel, ICsAttributes, IDotNetMember, IDotNetModel, IModelStatus, ISourceFiles, IDotNetAttributes, IDocumentation, ILookup, IParent, IParent
Properties
| Improve this Doc View SourceMemberType
The type of member the model is.
Declaration
CsMemberType MemberType { get; }
Property Value
| Type | Description |
|---|---|
| CsMemberType |
Security
The security scope that has been assigned to the member.
Declaration
CsSecurity Security { get; }
Property Value
| Type | Description |
|---|---|
| CsSecurity |
Methods
| Improve this Doc View SourceAddAfterAsync(String)
Adds the source code directly after the definition of the ICsMemberin the target document.
Declaration
Task<CsSource> AddAfterAsync(string sourceCode)
Parameters
| Type | Name | Description |
|---|---|---|
| String | sourceCode | The source code that is to be added to the document. |
Returns
| Type | Description |
|---|---|
| Task<CsSource> | A newly loaded copy of the ICsSource model after the changes have been applied. |
Exceptions
| Type | Condition |
|---|---|
| DocumentException | Error is raised when errors occur updating the source document. |
AddAfterAsync(String, String)
Adds the source code directly after the definition of the ICsMemberin the target document.
Declaration
Task<CsSource> AddAfterAsync(string sourceDocument, string sourceCode)
Parameters
| Type | Name | Description |
|---|---|---|
| String | sourceDocument | The fully qualified path to the source code document to be updated. |
| String | sourceCode | The source code that is to be added to the document. |
Returns
| Type | Description |
|---|---|
| Task<CsSource> | A newly loaded copy of the ICsSource model after the changes have been applied. |
Exceptions
| Type | Condition |
|---|---|
| DocumentException | Error is raised when errors occur updating the source document. |
AddBeforeAsync(String)
Adds the source code directly before the definition of the ICsMemberin the target document.
Declaration
Task<CsSource> AddBeforeAsync(string sourceCode)
Parameters
| Type | Name | Description |
|---|---|---|
| String | sourceCode | The source code that is to be added to the document. |
Returns
| Type | Description |
|---|---|
| Task<CsSource> | A newly loaded copy of the ICsSource model after the changes have been applied. |
Exceptions
| Type | Condition |
|---|---|
| DocumentException | Error is raised when errors occur updating the source document. |
AddBeforeAsync(String, String)
Adds the source code directly before the definition of the ICsMemberin the target document.
Declaration
Task<CsSource> AddBeforeAsync(string sourceDocument, string sourceCode)
Parameters
| Type | Name | Description |
|---|---|---|
| String | sourceDocument | The fully qualified path to the source code document to be updated. |
| String | sourceCode | The source code that is to be added to the document. |
Returns
| Type | Description |
|---|---|
| Task<CsSource> | A newly loaded copy of the ICsSource model after the changes have been applied. |
Exceptions
| Type | Condition |
|---|---|
| DocumentException | Error is raised when errors occur updating the source document. |
DeleteAsync()
Deletes the definition of the member from the source document.
Declaration
Task<CsSource> DeleteAsync()
Returns
| Type | Description |
|---|---|
| Task<CsSource> | A newly loaded copy of the ICsSource model after the member has been removed from the document. |
Exceptions
| Type | Condition |
|---|---|
| DocumentException | Error is raised when errors occur updating the source document. |
DeleteAsync(String)
Deletes the definition of the member from the source document.
Declaration
Task<CsSource> DeleteAsync(string sourceDocument)
Parameters
| Type | Name | Description |
|---|---|---|
| String | sourceDocument | The source document that the member is to be removed from. |
Returns
| Type | Description |
|---|---|
| Task<CsSource> | A newly loaded copy of the ICsSource model after the member has been removed from the document. |
Exceptions
| Type | Condition |
|---|---|
| DocumentException | Error is raised when errors occur updating the source document. |
GetModel(String)
Gets a ICsModel from the currently loaded source code.
Declaration
CsModel GetModel(string lookupPath)
Parameters
| Type | Name | Description |
|---|---|---|
| String | lookupPath | The fully qualified path to the model to be loaded. |
Returns
| Type | Description |
|---|---|
| CsModel | The loaded model or null if the model could not be found. |
GetSourceLocationAsync()
Gets the starting and ending locations within the document where the member is located.
Declaration
Task<ISourceLocation> GetSourceLocationAsync()
Returns
| Type | Description |
|---|---|
| Task<ISourceLocation> | The source location for the member. |
Exceptions
| Type | Condition |
|---|---|
| DocumentException | Raised when an error occurs getting the location from the document. |
GetSourceLocationAsync(String)
Gets the starting and ending locations within the document where the member is located.
Declaration
Task<ISourceLocation> GetSourceLocationAsync(string sourceDocument)
Parameters
| Type | Name | Description |
|---|---|---|
| String | sourceDocument | The fully qualified path to the document that has the member defined in. |
Returns
| Type | Description |
|---|---|
| Task<ISourceLocation> | The source location for the member. |
Exceptions
| Type | Condition |
|---|---|
| DocumentException | Raised when an error occurs getting the location from the document. |
ReplaceAsync(String)
Replaces the current member with the provided source code.
Declaration
Task<CsSource> ReplaceAsync(string sourceCode)
Parameters
| Type | Name | Description |
|---|---|---|
| String | sourceCode | The source code that is to be used to replace the original definition in the document. |
Returns
| Type | Description |
|---|---|
| Task<CsSource> | A newly loaded copy of the ICsSource model after the changes have been applied. |
Exceptions
| Type | Condition |
|---|---|
| DocumentException | Error is raised when errors occur updating the source document. |
ReplaceAsync(String, String)
Replaces the current member with the provided source code.
Declaration
Task<CsSource> ReplaceAsync(string sourceDocument, string sourceCode)
Parameters
| Type | Name | Description |
|---|---|---|
| String | sourceDocument | The fully qualified path to the source code document to be updated. |
| String | sourceCode | The source code that is to be used to replace the original definition in the document. |
Returns
| Type | Description |
|---|---|
| Task<CsSource> | A newly loaded copy of the ICsSource model after the changes have been applied. |
Exceptions
| Type | Condition |
|---|---|
| DocumentException | Error is raised when errors occur updating the source document. |


MEET JANET!


Awating Input...
Powered by threejs | speakjs | dancerjs | program-o | soundcloud | Created by Atmos Interactive


Parish Priest
Assistant Parish Priest
Priest
Priest
CASU(Catholic Students Union) is a student union that exists in many catholic parishes in Ghana. Membership is opened to all students from the Jonior Secondary School level up to the highest possible level of education one can attain. Members who have completed school are also encouraged to remain in the union.
Read moreThe Catholic Organisation for Social and Religious Advancement (COSRA) is a youth movement that appreciates the peculiar needs of the Ghanaian and for that matter the African youth and poses the right tools to address the social, economic, political and religious needs of young people.
Read moreA Catholic Youth Organization(CYO) member usually called a CRUSADER fights for the kingdom of God. The CYO nurtures the faith of catholic youth, their holistic growth, their leadership capabilities, their cultural and artistic talents, their love for family, community, our country Ghana and Africa.
Read moreThe Catholic Men’s Association (CMA) brings together all Catholic men into a Christian Community where they share God’s Word. They equip them with skills to help them reach their God given potential as Christian leaders and witnesses in the Church and Communities
Read moreThe Knights and Ladies of the Marshall is a Catholic Fraternal Organization in West Africa and London with its Supreme Headquarters in Sekondi. It brings Catholic men and women together to practice Unity, Charity and Service to honor and defend the Catholic Faith.
Read moreThe Society of St Vincent de Paul (SVP or SVdP or SSVP) is an international voluntary organization in the Catholic Church, founded in 1833 for the sanctification of its members by personal service of the poor. It is formed, led and managed by lay people. It always has a Spiritual Director.
Read moreThe Christian Mother’s Association is a Catholic women group. It was established in the early 1940's to offer holistic ministry to women, to make them well organised, self-reliant, self-sustaining and able to support the family upkeep.
Read moreThe Catholic Women Association is a community of catholic women who seek true renewal of spirituality of its members. It encourages its members to modal their lives after that of the Blessed Virgin Mary, their Patron Saint.
Read moreSt. Theresa of the Child Jesus Society is dynamic group in the Catholic Church established to bring together mostly women to be actively involved in the church’s activities and also in works of charity. It may have men.
Read moreSacared Heart of Jesus Confraternity is a student union that exists in many catholic parishes in Ghana. Membership is opened to all to the highest possible level of education one can attain. Members who have completed school are also encouraged to remain in the union.
Read moreThe Catholic Charistmatic Renewal (CCR) is a youth movement that appreciates the peculiar needs of the Ghanaian and for that matter the African youth and poses the right tools to address the social, economic, political and religious needs of young people.
Read moreThe Legion of Mary member usually called a CRUSADER fights for the kingdom of God. The CYO nurtures the faith of catholic youth, their holistic growth, their leadership capabilities, their cultural and artistic talents, their love for family, community, our country Ghana and Africa.
Read moreLector which include parish lectors, youth lectors and children is a group that exists in many catholic parishes in Ghana. Membership is opened to all.
Read moreThe Choir which includes the youth choir, children choir and parish choir is is a youth movement that appreciates the peculiar needs.
Read moreThe Knights and Ladies of the Altar(Knolta) are made up of children, youth and adult mass servers. They render faithful, reverent and edifying service to God.
Read more


TAG
[tæg]
noun
- a label attached to someone or something for the purpose of identification or to give other
information.
"he gave his pet a collar with a metal name tag"
synonyms: label, ticket, badge, mark, marker, tab, tally, sticker, docket, stub, chit, chitt, counterfoi, flag, stamp
"a price tag"
-
a small piece or part that is attached to a main body.
verb
- attach a label to.
"mothers suspected that their babies had been wrongly tagged during an alarm at
the hospital"
synonyms: label, attach tags to, put a label on, mark, ticket, earmark, identify,
docket, flag, indicate
"the bottles were tagged with colour-coded labels"
- add to something, especially as an afterthought or with no real connection.
"she meant to tag her question on at the end of her
remarks"
synonyms: add, tack, join, attach, append, affix, annex
"their heads were so large that the rest of their bodies seemed tagged on
as an afterthought"


The world of elementary particles is rather complex. There are many different classes and they can interact in a rather interesting way.
Two important characteristics of the elementary particles are the spin and the electric charge. Here are some of the elementary particles:
| Particle | Class | Spin | Electric charge |
| Strange | Quark | 1/2 | -1/3 |
| Charm | Quark | 1/2 | 2/3 |
| Electron | Lepton | 1/2 | -1 |
| Neutrino | Lepton | 1/2 | 0 |
| Photon | Boson | 1 | 0 |
Write a program that returns the particle and its class based on its spin and electric charge.
The input format:
Two lines: first the spin of the particle, then its charge. You do NOT have to convert these values to floats.
The output format:
The particle and its class separated by a space.


Picture Content Viewer will show the actual picture from the picture file.
Currently, Picture Content Viewer only support JPG, GIF, and PNG formats.
If you select an non-picture file or an unsupported picture format on the "Result Viewers", this tab will be disabled.
Here's one of the example of "Picture Content Viewer":


Gardaí launch murder investigation after man is shot dead in Coolock
by James CoxGardaí have launched a murder investigation after a man was shot dead in Coolock, north Dublin on Sunday.
The victim was named locally last night as Eoin Boylan.
Boylan, 22, died at Beaumont Hospital after a "number of apparent gunshot wounds".
The shooting took place on Clonshaugh Avenue in Dublin 17 at approximately 5:15pm on Sunday.
Gardaí suspect that the murder is linked to the ongoing gang feud in Coolock.
Minister for Justice Charlie Flanagan has condemned the attack.
“I was deeply concerned to hear of the shooting this evening in the Clonshaugh area. I condemn this wanton violence,” he said.
“I urge anyone with information to please contact An Garda Síochána and assist them with their investigation.”
Gardaí in Coolock opened a murder inquiry on Sunday evening.
A Garda statement reads: “Members of the Garda Technical Bureau are currently examining the scene and an incident room has been established at Coolock Garda station.
“The coroner has been notified and the services of the State Pathologist have been requested. Arrangements are being made for a postmortem examination.”
Gardaí in Coolock have appealed for any witnesses to come forward.
Any dashcam footage recorded in the vicinity of Clonshaugh Avenue between 4.30pm and 5.30pm on Sunday should be handed over to gardaí.


{%extends 'base.html'%} {% load bootstrap3 %} {% block content %} {{ block.super}}
{{neighborhood.name}} Estate.
Neighborhood Name : {{neighborhood.name}}
Location : {{neighborhood.location}}
Country : {{neighborhood.country}}
Posted on : {{neighborhood.pub_date}}


Plugin Information |
|---|
View Liquibase Runner on the plugin site for more information. |
Older versions of this plugin may not be safe to use. Please review the following warnings before using an older version:
Provides Liquibase build steps that evaluate liquibase changesets.
Important Upgrade Information
Version 1.2.0 now uses the Credentials Plugin to manage usernames and passwords to connect to the database. If you were using username & password configuration in the previous version of this plugin, be aware that credentials will be automatically created upon plugin update.
Features
Adds liquibase related operations (update, rollback, and dbdoc generation) as available build steps. See Liquibase documentation at http://www.liquibase.org.
Evaluated changesets and their details appear on the build's summary page.
Uses liquibase version 3.5.3.
Known Limitations
- Jenkins master will need to be able to connect to the target database. If, due to network constraints, your Jenkins slave node can initiate this connection but your Jenkins master cannot, consider the workaround described in JENKINS-41002, which uses port forwarding to facilitate database connectivity.
Installation
- Install the liquibase-runner plugin using Jenkins' plugin manager. Depending on how you use and configure the plugin, you may need to install a database server, and potentially your target schema.
- Once installed, three build steps are made available: "Evaluate liquibase changesets", "Generate Liquibase dbDoc", and "Rollback liquibase changes".
Common Configuration Amongst Builders
Simplest
By default, the plugin will use an instance of an H2 in-memory database, so you need only define the location of your changeset file. Note that changes won't be persisted across builds (though you may persist the H2 database to disk, see tips).
Advanced
Those who would like more control over liquibase configuration may do so using options presented when using the "advanced" section of the builder configuration. Here you'll find most of liquibase's configuration exposed, including contexts and the JDBC URL used to access the database.
For convenience, the plugin includes a few database drivers for use. Alternatively, you may also define a classpath where a database driver may be loaded, and the driver classname.
Note that individual configuration values will override any found in a defined liquibase properties file. This emulates how command-line usage of liquibase works.
Evaluate liquibase changesets step
Creating a job with this build step will run liquibase's update on the target database. Alternatively, by checking "Test Rollbacks", liquibase's updateTestingRollbacks is executed. Once a build has executed, details are provided about each changeset on the build summary.
Rollback liquibase changes step
The rollback build step invokes liquibase's "rollback" operation on the target database. There are a few rollback strategies to choose from that correspond to liquibase's rollback commands (by tag, by date, and by count).
This build step is intended for use when you're deploying to a real environment, and the need arises to undo a previous liquibase update.
DbDoc Generation
This build step generates Liquibase's dbDoc based on the supplied changelog. See liquibase documentation.
It is recommended to use this in conjunction with the HTMLPublisher plugin
Pipeline Support
All liquibase operations are available to pipeline scripts. See documentation for information and examples.
Job DSL Integration
See documentation regarding
how to use the JobDSL plugin to generate liquibase projects.
Usage Tips
- If you'd like to have only new changesets evaluated, consider using an H2 JDBC url like
"jdbc:h2:file:./data/sample". This instructs H2 to persist the database to a file. Note, however, if a different
build slave runs your project, that file will no longer be available, and all changesets will again be executed.
Version History
Version 1.3.0 (Feb 2, 2017)
- JENKINS-41681 Update plugin to use liquibase 3.5.3
- JENKINS-41655 liquibase runner causes 'schema_name()' error when used with jtds
- JENKINS-40963 Allow Liquibase runner to integrate with Job DSL plugin
Version 1.2.1 (Jan 9, 2017)
- JENKINS-40920 Credentials migration fails if project has more than one liquibase builder
- JENKINS-40919 Upgrading to 1.2.0 of the liquibase plugin may result in old-data warning
Version 1.2.0 (Jan 7, 2017)
- JENKINS-33401 Credentials Integration
- JENKINS-40816 Provide liquibase dbdoc generation build step
- JENKINS-40707 Pipeline Support
1.1.0 (Aug 30, 2016)
Thanks to David Siegal for suggestions, testing, and guidance for this release.
- JENKINS-37591 Upgraded to use Liquibase 3.5.1
- JENKINS-37700 Allow base path to be set.
- JENKINS-37699 Allow expressions in configuration fields
- JENKINS-37420 Added roll back build step
- JENKINS-37592 Tag on successful update.
- JENKINS-37637 Allow changesets to be loaded from classpath.
1.0.2 (May 4, 2016)
- Initial Release
Attachments:
changeset-listing.png (image/png)
changeset-detail.png (image/png)
dbdoc.png (image/png)


We will give you a call to confirm your booking date.
We will give you a call to confirm your booking time.


Intro
I am a 2nd year Graduate student at Electronics and Computer Engineering, University of California, San Diego. My area of research lie at the intersection of Planning using Reinforcement Learning, Computer Vision, Autonomous Driving and Deep Learning. Prior to this, I have worked at Microsoft and Uber in Applied Machine Learning products.


About GDJ Entertainment
One stop shop for all your music entertainment needs. Provides quality Party Bands/Musicians, DJ, and Professional Audio and Lighting Services.
The Founder
DJ Gee - Gerry De Jesus
GDJ Entertainment was founded by Gerry De Jesus. He is a passionate musician who wanted to share his passion through music. Gerry considers playing music as an expression of himself. Each event is carefully planned and prepared in advance to cater each client's needs. The company's goal is to provide affordable musical entertainment and services without sacrificing quality.
Follow Gerry De Jesus on Facebook
FollowThe Company
GDJ Entertainment is comprised of BiGLiST 90's Rock Cover Band, MiXeD uP! Party Band, and The JazzBox Smooth Jazz Band. It also provides DJ and Pro Audio and Lighting Services. It is managed and owned by Gerry De Jesus and is the drummer for all 3 bands and is the official/resident DJ joined by Sound Engineer, Brando Cayabyab and Pro Light Specialist, Leonard Vergara. We specialize in all kinds of events from birthday parties, debut, school dances, corporate and private events, and weddings.
Watch our performances on Youtube
Like Page


How This Site Works
Requirments
Updating the sites events requires Python2.7.
Account Information
A list of accounts and their information is in Chris C's google drive
Updating Events
Updating events requires the updating of the /js/events.js file. To update events:
- Open the /js/events.js file in an editor
- Copy and paste an exsisting event where it occurs on the timeline of events
- Update the event info
- When done editing, save the file
- Save the events image in to the /img/event-images folder and copy and paste the file name you updated in the events.js to rename it
- In the command prompt, navigate to /python/ and run "python build.py". This does a number of things including:
- Updating the /js/events.json/ file with the new events from the events.js file. The home page, calendar page, and past events page all use this to build their event timelines (I think, main.js should be looked at)
- Creates a minimized version of the events.js file (events-min.js)
- Takes the urls from the JSON file, including the ones that you added while editing and builds new populated HTML files for all events and places them in the special events folder.
- In a FTP, login to the hosting
- Copy event.js, events.json, and events-min.js into the /public_html/js/ folder, replacing the old files
- Copy the event image file into the /img/event-images/ folder
- Copy the speciffic event HTML pages that we created (NOTE: you dont need to upload all the html files)
- Close the FTP
- Upload the new files to GitHub. In the command prompt:
- git add --a
- git commit -m "What you did in this version"
- git push
- Check the site.


This guide covers the basic layout features of Action Controller and Action View.
After reading this guide, you will know:
This guide focuses on the interaction between Controller and View in the Model-View-Controller triangle. As you know, the Controller is responsible for orchestrating the whole process of handling a request in Rails, though it normally hands off any heavy code to the Model. But then, when it’s time to send a response back to the user, the Controller hands things off to the View. It’s that handoff that is the subject of this guide.
In broad strokes, this involves deciding what should be sent as the response and calling an appropriate method to create that response. If the response is a full-blown view, Rails also does some extra work to wrap the view in a layout and possibly to pull in partial views. You’ll see all of those paths later in this guide.
From the controller’s point of view, there are three ways to create an HTTP response:
render
to create a full response to send back to the browserredirect_to
to send an HTTP redirect status code to the browserhead
to create a response consisting solely of HTTP headers to send back to the browserYou’ve heard that Rails promotes “convention over configuration”. Default rendering is an excellent example of this. By default, controllers in Rails automatically render views with names that correspond to valid routes. For example, if you have this code in your BooksController
class:
class BooksController < ApplicationController end
And the following in your routes file:
resources :books
And you have a view file app/views/books/index.html.erb
:
~~~html+erb
Rails will automatically render `app/views/books/index.html.erb` when you navigate to `/books` and you will see "Books are coming soon!" on your screen.
However a coming soon screen is only minimally useful, so you will soon create your `Book` model and add the index action to `BooksController`:
~~~ruby
class BooksController < ApplicationController
def index
@books = Book.all
end
end
Note that we don’t have explicit render at the end of the index action in accordance with “convention over configuration” principle. The rule is that if you do not explicitly render something at the end of a controller action, Rails will automatically look for the action_name.html.erb
template in the controller’s view path and render it. So in this case, Rails will render the app/views/books/index.html.erb
file.
If we want to display the properties of all the books in our view, we can do so with an ERB template like this:
~~~html+erb
| Title | Summary | |||
|---|---|---|---|---|
| <%= book.title %> | <%= book.content %> | <%= link_to "Show", book %> | <%= link_to "Edit", edit_book_path(book) %> | <%= link_to "Remove", book, method: :delete, data: { confirm: "Are you sure?" } %> |
<%= link_to “New book”, new_book_path %> ~~~
NOTE: The actual rendering is done by subclasses of ActionView::TemplateHandlers
. This guide does not dig into that process, but it’s important to know that the file extension on your view controls the choice of template handler. Beginning with Rails 2, the standard extensions are .erb
for ERB (HTML with embedded Ruby), and .builder
for Builder (XML generator).
render
In most cases, the ActionController::Base#render
method does the heavy lifting of rendering your application’s content for use by a browser. There are a variety of ways to customize the behavior of render
. You can render the default view for a Rails template, or a specific template, or a file, or inline code, or nothing at all. You can render text, JSON, or XML. You can specify the content type or HTTP status of the rendered response as well.
TIP: If you want to see the exact results of a call to render
without needing to inspect it in a browser, you can call render_to_string
. This method takes exactly the same options as render
, but it returns a string instead of sending a response back to the browser.
Perhaps the simplest thing you can do with render
is to render nothing at all:
render nothing: true
If you look at the response for this using cURL, you will see the following:
$ curl -i <IP_ADDRESS>:3000/books HTTP/1.1 200 OK Connection: close Date: Sun, 24 Jan 2010 09:25:18 GMT Transfer-Encoding: chunked Content-Type: */*; charset=utf-8 X-Runtime: 0.014297 Set-Cookie: _blog_session=...snip...; path=/; HttpOnly Cache-Control: no-cache $
We see there is an empty response (no data after the Cache-Control
line), but the request was successful because Rails has set the response to 200 OK. You can set the :status
option on render to change this response. Rendering nothing can be useful for Ajax requests where all you want to send back to the browser is an acknowledgment that the request was completed.
TIP: You should probably be using the head
method, discussed later in this guide, instead of render :nothing
. This provides additional flexibility and makes it explicit that you’re only generating HTTP headers.
If you want to render the view that corresponds to a different template within the same controller, you can use render
with the name of the view:
def update @book = Book.find(params[:id]) if @book.update(params[:book]) redirect_to(@book) else render "edit" end end
If the call to update
fails, calling the update
action in this controller will render the edit.html.erb
template belonging to the same controller.
If you prefer, you can use a symbol instead of a string to specify the action to render:
def update @book = Book.find(params[:id]) if @book.update(params[:book]) redirect_to(@book) else render :edit end end
What if you want to render a template from an entirely different controller from the one that contains the action code? You can also do that with render
, which accepts the full path (relative to app/views
) of the template to render. For example, if you’re running code in an AdminProductsController
that lives in app/controllers/admin
, you can render the results of an action to a template in app/views/products
this way:
render "products/show"
Rails knows that this view belongs to a different controller because of the embedded slash character in the string. If you want to be explicit, you can use the :template
option (which was required on Rails 2.2 and earlier):
render template: "products/show"
The render
method can also use a view that’s entirely outside of your application (perhaps you’re sharing views between two Rails applications):
render "/u/apps/warehouse_app/current/app/views/products/show"
Rails determines that this is a file render because of the leading slash character. To be explicit, you can use the :file
option (which was required on Rails 2.2 and earlier):
render file: "/u/apps/warehouse_app/current/app/views/products/show"
The :file
option takes an absolute file-system path. Of course, you need to have rights to the view that you’re using to render the content.
NOTE: By default, the file is rendered without using the current layout. If you want Rails to put the file into the current layout, you need to add the layout: true
option.
TIP: If you’re running Rails on Microsoft Windows, you should use the :file
option to render a file, because Windows filenames do not have the same format as Unix filenames.
The above three ways of rendering (rendering another template within the controller, rendering a template within another controller and rendering an arbitrary file on the file system) are actually variants of the same action.
In fact, in the BooksController class, inside of the update action where we want to render the edit template if the book does not update successfully, all of the following render calls would all render the edit.html.erb
template in the views/books
directory:
render :edit render action: :edit render "edit" render "edit.html.erb" render action: "edit" render action: "edit.html.erb" render "books/edit" render "books/edit.html.erb" render template: "books/edit" render template: "books/edit.html.erb" render "/path/to/rails/app/views/books/edit" render "/path/to/rails/app/views/books/edit.html.erb" render file: "/path/to/rails/app/views/books/edit" render file: "/path/to/rails/app/views/books/edit.html.erb"
Which one you use is really a matter of style and convention, but the rule of thumb is to use the simplest one that makes sense for the code you are writing.
render
with :inline
The render
method can do without a view completely, if you’re willing to use the :inline
option to supply ERB as part of the method call. This is perfectly valid:
render inline: "<% products.each do |p| %>
<%= p.name %>
<% end %>"
WARNING: There is seldom any good reason to use this option. Mixing ERB into your controllers defeats the MVC orientation of Rails and will make it harder for other developers to follow the logic of your project. Use a separate erb view instead.
By default, inline rendering uses ERB. You can force it to use Builder instead with the :type
option:
render inline: "xml.p {'Horrid coding practice!'}", type: :builder
You can send plain text - with no markup at all - back to the browser by using the :text
option to render
:
render text: "OK"
TIP: Rendering pure text is most useful when you’re responding to Ajax or web service requests that are expecting something other than proper HTML.
NOTE: By default, if you use the :text
option, the text is rendered without using the current layout. If you want Rails to put the text into the current layout, you need to add the layout: true
option.
JSON is a JavaScript data format used by many Ajax libraries. Rails has built-in support for converting objects to JSON and rendering that JSON back to the browser:
render json: @product
TIP: You don’t need to call to_json
on the object that you want to render. If you use the :json
option, render
will automatically call to_json
for you.
Rails also has built-in support for converting objects to XML and rendering that XML back to the caller:
render xml: @product
TIP: You don’t need to call to_xml
on the object that you want to render. If you use the :xml
option, render
will automatically call to_xml
for you.
Rails can render vanilla JavaScript:
render js: "alert('Hello Rails');"
This will send the supplied string to the browser with a MIME type of text/javascript
.
render
Calls to the render
method generally accept four options:
:content_type
:layout
:location
:status
:content_type
OptionBy default, Rails will serve the results of a rendering operation with the MIME content-type of text/html
(or application/json
if you use the :json
option, or application/xml
for the :xml
option.). There are times when you might like to change this, and you can do so by setting the :content_type
option:
render file: filename, content_type: "application/rss"
:layout
OptionWith most of the options to render
, the rendered content is displayed as part of the current layout. You’ll learn more about layouts and how to use them later in this guide.
You can use the :layout
option to tell Rails to use a specific file as the layout for the current action:
render layout: "special_layout"
You can also tell Rails to render with no layout at all:
render layout: false
:location
OptionYou can use the :location
option to set the HTTP Location
header:
render xml: photo, location: photo_url(photo)
:status
OptionRails will automatically generate a response with the correct HTTP status code (in most cases, this is 200 OK
). You can use the :status
option to change this:
render status: 500 render status: :forbidden
Rails understands both numeric status codes and the corresponding symbols shown below.
| Response Class | HTTP Status Code | Symbol |
|---|---|---|
| Informational | 100 | :continue |
| 101 | :switching_protocols | |
| 102 | :processing | |
| Success | 200 | :ok |
| 201 | :created | |
| 202 | :accepted | |
| 203 | :non_authoritative_information | |
| 204 | :no_content | |
| 205 | :reset_content | |
| 206 | :partial_content | |
| 207 | :multi_status | |
| 208 | :already_reported | |
| 226 | :im_used | |
| Redirection | 300 | :multiple_choices |
| 301 | :moved_permanently | |
| 302 | :found | |
| 303 | :see_other | |
| 304 | :not_modified | |
| 305 | :use_proxy | |
| 306 | :reserved | |
| 307 | :temporary_redirect | |
| 308 | :permanent_redirect | |
| Client Error | 400 | :bad_request |
| 401 | :unauthorized | |
| 402 | :payment_required | |
| 403 | :forbidden | |
| 404 | :not_found | |
| 405 | :method_not_allowed | |
| 406 | :not_acceptable | |
| 407 | :proxy_authentication_required | |
| 408 | :request_timeout | |
| 409 | :conflict | |
| 410 | :gone | |
| 411 | :length_required | |
| 412 | :precondition_failed | |
| 413 | :request_entity_too_large | |
| 414 | :request_uri_too_long | |
| 415 | :unsupported_media_type | |
| 416 | :requested_range_not_satisfiable | |
| 417 | :expectation_failed | |
| 422 | :unprocessable_entity | |
| 423 | :locked | |
| 424 | :failed_dependency | |
| 426 | :upgrade_required | |
| 423 | :precondition_required | |
| 424 | :too_many_requests | |
| 426 | :request_header_fields_too_large | |
| Server Error | 500 | :internal_server_error |
| 501 | :not_implemented | |
| 502 | :bad_gateway | |
| 503 | :service_unavailable | |
| 504 | :gateway_timeout | |
| 505 | :http_version_not_supported | |
| 506 | :variant_also_negotiates | |
| 507 | :insufficient_storage | |
| 508 | :loop_detected | |
| 510 | :not_extended | |
| 511 | :network_authentication_required |
To find the current layout, Rails first looks for a file in app/views/layouts
with the same base name as the controller. For example, rendering actions from the PhotosController
class will use app/views/layouts/photos.html.erb
(or app/views/layouts/photos.builder
). If there is no such controller-specific layout, Rails will use app/views/layouts/application.html.erb
or app/views/layouts/application.builder
. If there is no .erb
layout, Rails will use a .builder
layout if one exists. Rails also provides several ways to more precisely assign specific layouts to individual controllers and actions.
You can override the default layout conventions in your controllers by using the layout
declaration. For example:
class ProductsController < ApplicationController layout "inventory" #... end
With this declaration, all of the views rendered by the products controller will use app/views/layouts/inventory.html.erb
as their layout.
To assign a specific layout for the entire application, use a layout
declaration in your ApplicationController
class:
class ApplicationController < ActionController::Base layout "main" #... end
With this declaration, all of the views in the entire application will use app/views/layouts/main.html.erb
for their layout.
You can use a symbol to defer the choice of layout until a request is processed:
class ProductsController < ApplicationController layout :products_layout def show @product = Product.find(params[:id]) end private def products_layout @current_user.special? ? "special" : "products" end end
Now, if the current user is a special user, they’ll get a special layout when viewing a product.
You can even use an inline method, such as a Proc, to determine the layout. For example, if you pass a Proc object, the block you give the Proc will be given the controller
instance, so the layout can be determined based on the current request:
class ProductsController < ApplicationController layout Proc.new { |controller| controller.request.xhr? ? "popup" : "application" } end
Layouts specified at the controller level support the :only
and :except
options. These options take either a method name, or an array of method names, corresponding to method names within the controller:
class ProductsController < ApplicationController layout "product", except: [:index, :rss] end
With this declaration, the product
layout would be used for everything but the rss
and index
methods.
Layout declarations cascade downward in the hierarchy, and more specific layout declarations always override more general ones. For example:
application_controller.rb
~~~ruby class ApplicationController < ActionController::Base layout “main” end ~~~
posts_controller.rb
~~~ruby class PostsController < ApplicationController end ~~~
special_posts_controller.rb
~~~ruby class SpecialPostsController < PostsController layout “special” end ~~~
old_posts_controller.rb
~~~ruby class OldPostsController < SpecialPostsController layout false
def show
@post = Post.find(params[:id])
end
def index
@old_posts = Post.older
render layout: "old"
end
# ... end ~~~
In this application:
main
layoutPostsController#index
will use the main
layoutSpecialPostsController#index
will use the special
layoutOldPostsController#show
will use no layout at allOldPostsController#index
will use the old
layoutSooner or later, most Rails developers will see the error message “Can only render or redirect once per action”. While this is annoying, it’s relatively easy to fix. Usually it happens because of a fundamental misunderstanding of the way that render
works.
For example, here’s some code that will trigger this error:
def show @book = Book.find(params[:id]) if @book.special? render action: "special_show" end render action: "regular_show" end
If @book.special?
evaluates to true
, Rails will start the rendering process to dump the @book
variable into the special_show
view. But this will not stop the rest of the code in the show
action from running, and when Rails hits the end of the action, it will start to render the regular_show
view - and throw an error. The solution is simple: make sure that you have only one call to render
or redirect
in a single code path. One thing that can help is and return
. Here’s a patched version of the method:
def show @book = Book.find(params[:id]) if @book.special? render action: "special_show" and return end render action: "regular_show" end
Make sure to use and return
instead of && return
because && return
will not work due to the operator precedence in the Ruby Language.
Note that the implicit render done by ActionController detects if render
has been called, so the following will work without errors:
def show @book = Book.find(params[:id]) if @book.special? render action: "special_show" end end
This will render a book with special?
set with the special_show
template, while other books will render with the default show
template.
redirect_to
Another way to handle returning responses to an HTTP request is with redirect_to
. As you’ve seen, render
tells Rails which view (or other asset) to use in constructing a response. The redirect_to
method does something completely different: it tells the browser to send a new request for a different URL. For example, you could redirect from wherever you are in your code to the index of photos in your application with this call:
redirect_to photos_url
You can use redirect_to
with any arguments that you could use with link_to
or url_for
. There’s also a special redirect that sends the user back to the page they just came from:
redirect_to :back
Rails uses HTTP status code 302, a temporary redirect, when you call redirect_to
. If you’d like to use a different status code, perhaps 301, a permanent redirect, you can use the :status
option:
redirect_to photos_path, status: 301
Just like the :status
option for render
, :status
for redirect_to
accepts both numeric and symbolic header designations.
render
and redirect_to
Sometimes inexperienced developers think of redirect_to
as a sort of goto
command, moving execution from one place to another in your Rails code. This is not correct. Your code stops running and waits for a new request for the browser. It just happens that you’ve told the browser what request it should make next, by sending back an HTTP 302 status code.
Consider these actions to see the difference:
def index @books = Book.all end def show @book = Book.find_by_id(params[:id]) if @book.nil? render action: "index" end end
With the code in this form, there will likely be a problem if the @book
variable is nil
. Remember, a render :action
doesn’t run any code in the target action, so nothing will set up the @books
variable that the index
view will probably require. One way to fix this is to redirect instead of rendering:
def index @books = Book.all end def show @book = Book.find_by_id(params[:id]) if @book.nil? redirect_to action: :index end end
With this code, the browser will make a fresh request for the index page, the code in the index
method will run, and all will be well.
The only downside to this code is that it requires a round trip to the browser: the browser requested the show action with /books/1
and the controller finds that there are no books, so the controller sends out a 302 redirect response to the browser telling it to go to /books/
, the browser complies and sends a new request back to the controller asking now for the index
action, the controller then gets all the books in the database and renders the index template, sending it back down to the browser which then shows it on your screen.
While in a small application, this added latency might not be a problem, it is something to think about if response time is a concern. We can demonstrate one way to handle this with a contrived example:
def index @books = Book.all end def show @book = Book.find_by_id(params[:id]) if @book.nil? @books = Book.all flash[:alert] = "Your book was not found" render "index" end end
This would detect that there are no books with the specified ID, populate the @books
instance variable with all the books in the model, and then directly render the index.html.erb
template, returning it to the browser with a flash alert message to tell the user what happened.
head
To Build Header-Only ResponsesThe head
method can be used to send responses with only headers to the browser. It provides a more obvious alternative to calling render :nothing
. The head
method accepts a number or symbol (see reference table) representing a HTTP status code. The options argument is interpreted as a hash of header names and values. For example, you can return only an error header:
head :bad_request
This would produce the following header:
HTTP/1.1 400 Bad Request
Connection: close
Date: Sun, 24 Jan 2010 12:15:53 GMT
Transfer-Encoding: chunked
Content-Type: text/html; charset=utf-8
X-Runtime: 0.013483
Set-Cookie: _blog_session=...snip...; path=/; HttpOnly
Cache-Control: no-cache
Or you can use other HTTP headers to convey other information:
head :created, location: photo_path(@photo)
Which would produce:
HTTP/1.1 201 Created
Connection: close
Date: Sun, 24 Jan 2010 12:16:44 GMT
Transfer-Encoding: chunked
Location: /photos/1
Content-Type: text/html; charset=utf-8
X-Runtime: 0.083496
Set-Cookie: _blog_session=...snip...; path=/; HttpOnly
Cache-Control: no-cache
When Rails renders a view as a response, it does so by combining the view with the current layout, using the rules for finding the current layout that were covered earlier in this guide. Within a layout, you have access to three tools for combining different bits of output to form the overall response:
yield
and content_for
Asset tag helpers provide methods for generating HTML that link views to feeds, JavaScript, stylesheets, images, videos and audios. There are six asset tag helpers available in Rails:
auto_discovery_link_tag
javascript_include_tag
stylesheet_link_tag
image_tag
video_tag
audio_tag
You can use these tags in layouts or other views, although the auto_discovery_link_tag
, javascript_include_tag
, and stylesheet_link_tag
, are most commonly used in the
section of a layout.
WARNING: The asset tag helpers do not verify the existence of the assets at the specified locations; they simply assume that you know what you’re doing and generate the link.
auto_discovery_link_tag
The auto_discovery_link_tag
helper builds HTML that most browsers and newsreaders can use to detect the presence of RSS or Atom feeds. It takes the type of the link (:rss
or :atom
), a hash of options that are passed through to url_for, and a hash of options for the tag:
<%= auto_discovery_link_tag(:rss, {action: "feed"},
{title: "RSS Feed"}) %>
There are three tag options available for the auto_discovery_link_tag
:
:rel
specifies the rel
value in the link. The default value is “alternate”.:type
specifies an explicit MIME type. Rails will generate an appropriate MIME type automatically.:title
specifies the title of the link. The default value is the uppercase :type
value, for example, “ATOM” or “RSS”.javascript_include_tag
The javascript_include_tag
helper returns an HTML script
tag for each source provided.
If you are using Rails with the Asset Pipeline enabled, this helper will generate a link to /assets/javascripts/
rather than public/javascripts
which was used in earlier versions of Rails. This link is then served by the asset pipeline.
A JavaScript file within a Rails application or Rails engine goes in one of three locations: app/assets
, lib/assets
or vendor/assets
. These locations are explained in detail in the Asset Organization section in the Asset Pipeline Guide
You can specify a full path relative to the document root, or a URL, if you prefer. For example, to link to a JavaScript file that is inside a directory called javascripts
inside of one of app/assets
, lib/assets
or vendor/assets
, you would do this:
<%= javascript_include_tag "main" %>
Rails will then output a script
tag such as this:

The request to this asset is then served by the Sprockets gem.
To include multiple files such as app/assets/javascripts/main.js
and app/assets/javascripts/columns.js
at the same time:
<%= javascript_include_tag "main", "columns" %>
To include app/assets/javascripts/main.js
and app/assets/javascripts/photos/columns.js
:
<%= javascript_include_tag "main", "/photos/columns" %>
To include http://example.com/main.js
:
<%= javascript_include_tag "http://example.com/main.js" %>
stylesheet_link_tag
The stylesheet_link_tag
helper returns an HTML <link>
tag for each source provided.
If you are using Rails with the “Asset Pipeline” enabled, this helper will generate a link to /assets/stylesheets/
. This link is then processed by the Sprockets gem. A stylesheet file can be stored in one of three locations: app/assets
, lib/assets
or vendor/assets
.
You can specify a full path relative to the document root, or a URL. For example, to link to a stylesheet file that is inside a directory called stylesheets
inside of one of app/assets
, lib/assets
or vendor/assets
, you would do this:
<%= stylesheet_link_tag "main" %>
To include app/assets/stylesheets/main.css
and app/assets/stylesheets/columns.css
:
<%= stylesheet_link_tag "main", "columns" %>
To include app/assets/stylesheets/main.css
and app/assets/stylesheets/photos/columns.css
:
<%= stylesheet_link_tag "main", "photos/columns" %>
To include http://example.com/main.css
:
<%= stylesheet_link_tag "http://example.com/main.css" %>
By default, the stylesheet_link_tag
creates links with media="screen" rel="stylesheet"
. You can override any of these defaults by specifying an appropriate option (:media
, :rel
):
<%= stylesheet_link_tag "main_print", media: "print" %>
image_tag
The image_tag
helper builds an HTML
tag to the specified file. By default, files are loaded from public/images
.
WARNING: Note that you must specify the extension of the image.
<%= image_tag "header.png" %>
You can supply a path to the image if you like:
<%= image_tag "icons/delete.gif" %>
You can supply a hash of additional HTML options:
<%= image_tag "icons/delete.gif", {height: 45} %>
You can supply alternate text for the image which will be used if the user has images turned off in their browser. If you do not specify an alt text explicitly, it defaults to the file name of the file, capitalized and with no extension. For example, these two image tags would return the same code:
<%= image_tag "home.gif" %> <%= image_tag "home.gif", alt: "Home" %>
You can also specify a special size tag, in the format “{width}x{height}”:
<%= image_tag "home.gif", size: "50x20" %>
In addition to the above special tags, you can supply a final hash of standard HTML options, such as :class
, :id
or :name
:
<%= image_tag "home.gif", alt: "Go Home",
id: "HomeImage",
class: "nav_bar" %>
video_tag
The video_tag
helper builds an HTML 5 <video>
tag to the specified file. By default, files are loaded from public/videos
.
<%= video_tag "movie.ogg" %>
Produces
<video src="/videos/movie.ogg" />
Like an image_tag
you can supply a path, either absolute, or relative to the public/videos
directory. Additionally you can specify the size: "#{width}x#{height}"
option just like an image_tag
. Video tags can also have any of the HTML options specified at the end (id
, class
et al).
The video tag also supports all of the <video>
HTML options through the HTML options hash, including:
poster: "image_name.png"
, provides an image to put in place of the video before it starts playing.autoplay: true
, starts playing the video on page load.loop: true
, loops the video once it gets to the end.controls: true
, provides browser supplied controls for the user to interact with the video.autobuffer: true
, the video will pre load the file for the user on page load.You can also specify multiple videos to play by passing an array of videos to the video_tag
:
<%= video_tag ["trailer.ogg", "movie.ogg"] %>
This will produce:
<video><source src="trailer.ogg" /><source src="movie.ogg" /></video>
audio_tag
The audio_tag
helper builds an HTML 5 <audio>
tag to the specified file. By default, files are loaded from public/audios
.
<%= audio_tag "music.mp3" %>
You can supply a path to the audio file if you like:
<%= audio_tag "music/first_song.mp3" %>
You can also supply a hash of additional options, such as :id
, :class
etc.
Like the video_tag
, the audio_tag
has special options:
autoplay: true
, starts playing the audio on page loadcontrols: true
, provides browser supplied controls for the user to interact with the audio.autobuffer: true
, the audio will pre load the file for the user on page load.yield
Within the context of a layout, yield
identifies a section where content from the view should be inserted. The simplest way to use this is to have a single yield
, into which the entire contents of the view currently being rendered is inserted:
~~~html+erb
<%= yield %>
You can also create a layout with multiple yielding regions:
~~~html+erb

<%= yield :head %>

<%= yield %>

The main body of the view will always render into the unnamed yield
. To render content into a named yield
, you use the content_for
method.
content_for
MethodThe content_for
method allows you to insert content into a named yield
block in your layout. For example, this view would work with the layout that you just saw:
~~~html+erb <% content_for :head do %>
<% end %>
Hello, Rails!
The result of rendering this page into the supplied layout would be this HTML:
~~~html+erb

<title>A simple page</title>

Hello, Rails!

The content_for
method is very helpful when your layout contains distinct regions such as sidebars and footers that should get their own blocks of content inserted. It’s also useful for inserting tags that load page-specific JavaScript or css files into the header of an otherwise generic layout.
Partial templates - usually just called “partials” - are another device for breaking the rendering process into more manageable chunks. With a partial, you can move the code for rendering a particular piece of a response to its own file.
To render a partial as part of a view, you use the render
method within the view:
<%= render "menu" %>
This will render a file named _menu.html.erb
at that point within the view being rendered. Note the leading underscore character: partials are named with a leading underscore to distinguish them from regular views, even though they are referred to without the underscore. This holds true even when you’re pulling in a partial from another folder:
<%= render "shared/menu" %>
That code will pull in the partial from app/views/shared/_menu.html.erb
.
One way to use partials is to treat them as the equivalent of subroutines: as a way to move details out of a view so that you can grasp what’s going on more easily. For example, you might have a view that looked like this:
<%= render "shared/ad_banner" %>
Products

Here are a few of our fine products:
 ... <%= render "shared/footer" %>
Here, the _ad_banner.html.erb
and _footer.html.erb
partials could contain content that is shared among many pages in your application. You don’t need to see the details of these sections when you’re concentrating on a particular page.
TIP: For content that is shared among all pages in your application, you can use partials directly from layouts.
A partial can use its own layout file, just as a view can use a layout. For example, you might call a partial like this:
<%= render partial: "link_area", layout: "graybar" %>
This would look for a partial named _link_area.html.erb
and render it using the layout _graybar.html.erb
. Note that layouts for partials follow the same leading-underscore naming as regular partials, and are placed in the same folder with the partial that they belong to (not in the master layouts
folder).
Also note that explicitly specifying :partial
is required when passing additional options such as :layout
.
You can also pass local variables into partials, making them even more powerful and flexible. For example, you can use this technique to reduce duplication between new and edit pages, while still keeping a bit of distinct content:
new.html.erb
~~~html+erb
<%= error_messages_for :zone %> <%= render partial: “form”, locals: {zone: @zone} %> ~~~
edit.html.erb
~~~html+erb
<%= error_messages_for :zone %> <%= render partial: “form”, locals: {zone: @zone} %> ~~~
_form.html.erb
~~~html+erb
<%= form_for(zone) do |f| %>

Zone name
<%= f.text_field :name %>

<%= f.submit %>

<% end %>
~~~
Although the same partial will be rendered into both views, Action View’s submit helper will return “Create Zone” for the new action and “Update Zone” for the edit action.
Every partial also has a local variable with the same name as the partial (minus the underscore). You can pass an object in to this local variable via the :object
option:
<%= render partial: "customer", object: @new_customer %>
Within the customer
partial, the customer
variable will refer to @new_customer
from the parent view.
If you have an instance of a model to render into a partial, you can use a shorthand syntax:
<%= render @customer %>
Assuming that the @customer
instance variable contains an instance of the Customer
model, this will use _customer.html.erb
to render it and will pass the local variable customer
into the partial which will refer to the @customer
instance variable in the parent view.
Partials are very useful in rendering collections. When you pass a collection to a partial via the :collection
option, the partial will be inserted once for each member in the collection:
index.html.erb
~~~html+erb
<%= render partial: “product”, collection: @products %> ~~~
_product.html.erb
~~~html+erb
Product Name: <%= product.name %>
~~~
When a partial is called with a pluralized collection, then the individual instances of the partial have access to the member of the collection being rendered via a variable named after the partial. In this case, the partial is _product
, and within the _product
partial, you can refer to product
to get the instance that is being rendered.
There is also a shorthand for this. Assuming @products
is a collection of product
instances, you can simply write this in the index.html.erb
to produce the same result:
~~~html+erb
<%= render @products %> ~~~
Rails determines the name of the partial to use by looking at the model name in the collection. In fact, you can even create a heterogeneous collection and render it this way, and Rails will choose the proper partial for each member of the collection:
index.html.erb
~~~html+erb
<%= render [customer1, employee1, customer2, employee2] %> ~~~
customers/_customer.html.erb
~~~html+erb
Customer: <%= customer.name %>
~~~
employees/_employee.html.erb
~~~html+erb
Employee: <%= employee.name %>
~~~
In this case, Rails will use the customer or employee partials as appropriate for each member of the collection.
In the event that the collection is empty, render
will return nil, so it should be fairly simple to provide alternative content.
~~~html+erb
<%= render(@products) || “There are no products available.” %> ~~~
To use a custom local variable name within the partial, specify the :as
option in the call to the partial:
<%= render partial: "product", collection: @products, as: :item %>
With this change, you can access an instance of the @products
collection as the item
local variable within the partial.
You can also pass in arbitrary local variables to any partial you are rendering with the locals: {}
option:
<%= render partial: "products", collection: @products,
as: :item, locals: {title: "Products Page"} %>
Would render a partial _products.html.erb
once for each instance of product
in the @products
instance variable passing the instance to the partial as a local variable called item
and to each partial, make the local variable title
available with the value Products Page
.
TIP: Rails also makes a counter variable available within a partial called by the collection, named after the member of the collection followed by _counter
. For example, if you’re rendering @products
, within the partial you can refer to product_counter
to tell you how many times the partial has been rendered. This does not work in conjunction with the as: :value
option.
You can also specify a second partial to be rendered between instances of the main partial by using the :spacer_template
option:
<%= render partial: @products, spacer_template: "product_ruler" %>
Rails will render the _product_ruler
partial (with no data passed in to it) between each pair of _product
partials.
When rendering collections it is also possible to use the :layout
option:
<%= render partial: "product", collection: @products, layout: "special_layout" %>
The layout will be rendered together with the partial for each item in the collection. The current object and object_counter variables will be available in the layout as well, the same way they do within the partial.
You may find that your application requires a layout that differs slightly from your regular application layout to support one particular controller. Rather than repeating the main layout and editing it, you can accomplish this by using nested layouts (sometimes called sub-templates). Here’s an example:
Suppose you have the following ApplicationController
layout:
app/views/layouts/application.html.erb
~~~html+erb
~~~
On pages generated by NewsController
, you want to hide the top menu and add a right menu:
app/views/layouts/news.html.erb
~~~html+erb <% content_for :stylesheets do %> #top_menu {display: none} #right_menu {float: right; background-color: yellow; color: black} <% end %> <% content_for :content do %>
Right menu items here
 <%= content_for?(:news_content) ? yield(:news_content) : yield %> <% end %> <%= render template: “layouts/application” %> ~~~
That’s it. The News views will use the new layout, hiding the top menu and adding a new right menu inside the “content” div.
There are several ways of getting similar results with different sub-templating schemes using this technique. Note that there is no limit in nesting levels. One can use the ActionView::render
method via render template: 'layouts/news'
to base a new layout on the News layout. If you are sure you will not subtemplate the News
layout, you can replace the content_for?(:news_content) ? yield(:news_content) : yield
with simply yield
.


Test anchor This elusive quality it is, which causes the thought of whiteness, when divorced from more kindly associations, and coupled with any object terrible in itself, to heighten that terror to the furthest bounds. Witness the white bear of the poles, and the white shark of the tropics; what but their smooth, flaky whiteness makes them the transcendent horrors they are?
 So that not the fierce-fanged tiger in his heraldic coat can so stagger courage as the white-shrouded bear or shark.
Test anchor With reference to the Polar bear, it may possibly be urged by him who would fain go still deeper into this matter, that it is not the whiteness, separately regarded, which heightens the intolerable hideousness of that brute; for, analysed, that heightened hideousness, it might be said, only rises from the circumstance, that the irresponsible ferociousness of the creature stands invested in the fleece of celestial innocence and love; and hence, by bringing together two such opposite emotions in our minds, the Polar bear frightens us with so unnatural a contrast.
Test anchor Something, such as a burrow or shell, that serves as a shelter or habitation for a wild animal. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis vitae, justo. Nullam dictum felis eu pede mollis pretium.
Test anchor The mature female of cattle of the genus Bos.
Test anchor The art that purports to control or forecast natural events, effects, or forces by invoking the supernatural.


Suggests using 'ng add' command to install the dependency.
'ng add' will use the package manager to download it and invoke a schematic
which can update your project with configuration changes, add additional dependencies (e.g. polyfills),
or scaffold package-specific initialization code.


Speed 3 limit
Percentage of maximum speed applied when Speed Switch set to Speed 3.
(see 'Speed switch mode' fore details)


---
title: Immutables.org
layout: default
---
{% capture v %}2.1.11{% endcapture %}
{% capture storySample0 %}{% include storySample0.md %}{% endcapture %}
{{ storySample0 | markdownify }}
{% capture storySample1 %}{% include storySample1.md %}{% endcapture %}
{{ storySample1 | markdownify }}
Classes, Interfaces and Annotations
Builders
Constuctor methods
With-copy methods
equals, toString, hashCode methods
Default attributes
Derived attributes
Lazy attributes
Optional attributes
Array, List, Set and Map attributes
Singleton values
Instance interning
hashCode precomputing
JSON serialization
JAX-RS integration
MongoDB integration


{% extends "email_messages/layout.html" %} {% block header_content %} New Workshop request {% endblock %} {% block content_body %} {% block content %}
Hello folks!
Your organization's {{ workshop_topic }} workshop request on {{ date }} has been successfully added! We shall be notifying all the regional leads and potential instructors soon.
Meanwhile, do visit the url below for more information. {{ workshop_url }}
May the love of Python spread far and wide!
Warmly,
The PythonExpress team
{% endblock %} {% endblock %}


Profile - About Me
I possess a Bachelor's Degree in Computer Science from UC Santa Cruz and Associate Degree in Mathematics and Physics from Mission College. As a passionate and motivated individual with hands-on experience in software engineering, I have a strong work ethic, a positive attitude and friendly manner, and an ability to learn quickly.
I worked as web developer intern for 2025. Also, I worked as webmaster for NSBE in UC Santa Cruz and MESA in Mission College. With the collaboration of a software team, I developed several projects in UC Santa Cruz using Agile Methodology.
I am big fan of Golden State Warriors. In my spare time, I'm probably watching movies, hiking or water rafting.


| Modular Application Framework Components | |
SubHook |
Top Previous |
|
A SubHook defines a single function in a module. It is a member to one DynamicFunction only, but its code can be assigned to several SubHooks. The SubHook uses a local ID to identify itself withion a module. This ID must be unique within the module and should be unique within the DynamicFunction. Additionally the SubHook has a global unique ID that is used for installation purposes. This ID is managed by the DFT automatically. If a new module wants to overwrite an existing SubHook with own code, it has to overwrite this unique ID, as it cannot be certain that the function still can be found using the combination HookID, SubHookID and ModuleID (due to the installation of another module before overwriting the same SubHook).
If the DynamicFunction doesn't exist when the SubHook gets installed, the DynamicFunction will be created.
|


{% extends "common-base.html" %} {% load custom_tags %} {% block title %}Client libraries and Plug-ins{% endblock %}endblock %} {% block common_content %}
We provide client libraries in several popular languages and a few plug-ins for various frameworks.
All libraries are published in a public repository, and we encourage you to share your improvements. If you have comments, suggestions or questions please let us know.
Remember that if none of the libraries fit your needs, you can develop your own based on the API specification.
| CLIENTS | PLUG-INS |
|---|---|
|
Python client library Python implementation of the API calls |
Wordpress Plug-in Insert IndexTank into your Wordpress blog |
|
Ruby client library Ruby implementation of the API calls |
|
|
PHP client library PHP implementation of the API calls |
Heroku Add-on Use IndexTank directly in your Heroku account |
|
Java client library Java implementation of the API calls |


I am a data scientist at RS Energy Group (RSEG). Before joining RSEG, I was a machine learning developer at AltaML. I graduated from the Department of Electrical and Computer Engineering, University of Alberta, Canada, with a Ph.D. in Software Engineering & Intelligent Systems. I received my B.Eng. (Computer Science and Technology) and M.Eng. (Computer Application Technology) from College of Information Engineering, Northwest Agricultural & Forestry University ("Project 985" top university), China.


Public
Owner: {{picture.username}}
Description: {{picture.description}}
Description: {{picture.description}}


Testing CDM and TDS
Utility Classes
CDM ucar.nc2.TestAll
Locate
existing data directories, setup a temporary test directory, and provide a number of static utility methods.
Static Variables
A number of directory paths are available in the following String variables:
- upcShareDir - The Unidata shared directory. Usually:
- "//zero/share/" or
- "zero:/upc/share"
- upcShareThreddsDataDir - The Unidata THREDDS data dir. Usually:
- "//zero/share/thredds/data/" or
- "zero:/upc/share/thredds/data
- testDataDir - The Unidata test data directory. Usually:
- "//newshemp/testdata",
- "//newshemp/data/testdata", or
- "newshemp:/data/testdata".
- cdmTestDataDir - the source code distributed data directory: "src/test/data/"
- temporaryDataDir - a temporary directory in the source code directory tree: "target/test/tmp/"
Data directories include:
- the Unidata test data directory
(/data/testdata on newshemp);
- the Unidata thredds data directory (/upc/share/thredds/data); and
- the CDM code repository test data
directory (cdm/src/test/data).
The temporary test directory:
- In the build directory (cdm/target/test/tmp).
Several system or user
properties are used. They can be set with "-Dproperty.name=value"
options on the JVM command-line or can be set in a "thredds.properties"
file in the "user.home" directory. An example:
unidata.upc.share.path=//zero/share/
unidata.testdata.path=//newshemp/testdata
The following static variables are provided for accessing the above directories:
- upcShareDir:String - "//zero/share/"
- upcShareTestDataDir:String - "//zero/share/testdata/" [NOTE: No longer exists]
- upcShareThreddsDataDir:String - "//zero/share/thredds/data/"
- upcShareDirFile:File - "//zero/share"
- testDataDir:File - "//newshemp/testdata
- cdmTestDataDir:String - "cdm/target/test/tmp/"
- temporaryDataDir:String - "target/test/tmp/"
Note
that all the String variables end with a slash ("/"). All are checked
that they exist (error messages are output if they don't or can't be
created).
The following static methods are provided:
- nearlyEquals(double,double):boolean
-
nearlyEquals(double,double,double):boolean
- nearlyEquals(float,float):boolean
- openAllInDir(String dirName, FileFilter ff)
- readAllDir(String dirName, FileFilter ff)
- ...
CDM ucar.unidata.utils.TestFileDirUtils
Static utility methods for creating directories and files.
CDM ucar.unidata.utils.TestDiskCacheUtils
Static utility methods for setup and emptying ucar.nc2.util.DiskCache and ucar.nc2.util.DiskCache2.
TDS thredds.tds.idd.TdsTestUtils
Static utility methods for setup for testing of TDS.
- getTargetTdsUrl():String
- Uses system properties "thredds.tds.test.server" and
"thredds.tds.test.port" to construct the base TDS URL. The default
value is "http://motherlode.ucar.edu:8080/thredds/".
TDS thredds.tds.idd.GridDatasetTestUtils
Static utility methods ...
TDS thredds.tds.idd.CompareGridVarNamesUtils
Static utility methods ...
TDS thredds.tds.idd.StandardCatalogUtils
Static methods that return Object[][] listing catalog URLs for use in JUnit parameterized tests.
- getIddMainCatalogUrls():Object[][]
- getIddDeepCatalogUrls():Object[][]
- getMlodeMainCatalogUrls():Object[][]
For instance, to use the main IDD catalogs as parameters for a test, include the following method in your test calls:
@Parameterized.Parameters
public static Collection<Object[]> getCatalogUrls()
{
List<Object[]> catUrls = new ArrayList<Object[]>(
Arrays.asList( StandardCatalogUtils.getIddMainCatalogUrls()));
return catUrls;
}
TDS thredds.tds.idd.IddModelDatasetsUtils
Static methods that return Object[][] that list IDs for model datasets for use in JUnit parameterized tests:
For instance, to use the model IDs as parameters for a test, include the following method in your test calls:
@Parameterized.Parameters
public static Collection<Object[]> getModelIds()
{
List<Object[]> catUrls = new ArrayList<Object[]>(
Arrays.asList( IddModelDatasetsUtils.getModelIds()));
return catUrls;
}
TDS thredds.TestAll
test
cdm/src/test/java/ucar/nc2/TestAll


{% comment %}
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
{% endcomment %}
{% load forms_helpers %}
{% if errors %}
There are errors on this form, please scroll down to see them.
Your changes have not been saved.
{% endif %}
{% if hidden_field_errors or top_errors %}


Team Members
Manager
Name: Michael Myers
ID: 1
Email<EMAIL_ADDRESS>Number:<PHONE_NUMBER>
Engineer
Name: Sonny
ID: 2
Email<EMAIL_ADDRESS>Github: Sonnybun87
Engineer
Name: Melody Jean
ID: 3
Email<EMAIL_ADDRESS>Github: MelMel007
Intern
Name: Mark David
ID: 4
Email<EMAIL_ADDRESS>School: USC


Art and poetry
Here is a collection of a mix of code poetry that I and friends like to call Post-Internet art.
- 7*7 Flowers Poem, 2015
- Alphabet Poem, 2014
- Love Season Poem, 2014
- 9*19 Flowers Poem, 2013
Right now my fire is to build things with your genomic data,Read about me here as a Mathematical Genomics and Medicine PhD student at Cambridge.
Previously I've been an ASI fellow, Advanced Computer Science student, Google intern, and
UCL Entrepreneurs president.
Here is a collection of a mix of code poetry that I and friends like to call Post-Internet art.


TB Test
An Admin can add/edit/delete TB tests of the OFD Personnel
A user will be able to view the dashboard as below after login
E-mail Address: User will fill in the email address.
Affiliation: User will click on TB Tests on dashboard and will be directed to the below page.
Start New Cycle User will click on "Start Cycle" button to begin a new cycle
Select firefighters for respective tests and click on "Start Test Cycle" button