BOOL isAlarmTypeAndValueMatch(ALARM_TYPE type,const char *value)
{
int row_num = 0,column_num = 0;
char sql[1024] = {0};
char **azResult;
if(database_open()==FALSE) return FALSE;
switch(type)
{
case ALARM_TYPE_EMAIL:
sprintf(sql,"select * from alarmtable where F_TYPE='email' and F_VALUE='%s'",value);
break;
case ALARM_TYPE_MOBILE:
sprintf(sql,"select * from alarmtable where F_TYPE='mobile' and F_VALUE='%s'",value);
break;
default:
return FALSE;
}
DEBUG_MSG("match sql = %s\n",sql);
sqlite3_get_table(db_user,sql, &azResult, &row_num, &column_num, NULL);
if(row_num>0){
sqlite3_free_table(azResult);
database_close();
return TRUE;
}
database_close();
return FALSE;
}
int issue_new_dialog_load_projects()
{
g_print("issue_new_dialog_load_projects()\n");
char *error_message = 0;
sqlite3 *db = database_open();
if (db == NULL) {
g_print("Can't open database: %s\n", sqlite3_errmsg(db));
sqlite3_close(db);
return -1;
}
const gchar sql_command[] = "SELECT project_id, name FROM project WHERE status = \"A\"";
int rc = sqlite3_exec(db, sql_command, project_query_callback, 0, &error_message);
if (rc != SQLITE_OK) {
g_print("SQL error: %s\n", error_message);
sqlite3_free(error_message);
}
sqlite3_close(db);
return 0;
}
void GetAlarmAllList(void)
{
if(database_open()==FALSE) return;
char *sql = "select F_TYPE,F_VALUE,F_STATE from alarmtable";
int row_num = 0,column_num = 0,i = 0;
char **azResult;
char buffer[1024] = {0};
sqlite3_get_table(db_user,sql, &azResult, &row_num, &column_num, NULL);
memset(g_alarm_alllist,0,sizeof(g_alarm_alllist));
if(row_num >= 1){
strcat(g_alarm_alllist,"[");
for(i = 1;i<row_num+1;i++)
{
//json send
sprintf(buffer,"{\"alarm_way\":\"%s\",\"alarm_value\":\"%s\",\"alarm_state\":\"%s\"},",azResult[ i*column_num],azResult[ i*column_num+1],azResult[ i*column_num+2]);
strcat(g_alarm_alllist,buffer);
memset(buffer,0,sizeof(buffer));
}
g_alarm_alllist[strlen(g_alarm_alllist)-1] = ']';
strcat(g_alarm_alllist,"\0");
DEBUG_MSG("alarmAllList = %s\n",g_alarm_alllist);
}
else{
strcpy(g_alarm_alllist,"_NULL_");
}
sqlite3_free_table(azResult);
database_close();
}
int project_edit_dialog_delete()
{
char *error_message = 0;
sqlite3 *db = database_open();
if (db == NULL) {
g_print("Can't open database: %s\n", sqlite3_errmsg(db));
sqlite3_close(db);
return -1;
}
gchar *sql_command = g_strdup_printf("DELETE FROM project WHERE project_id = \"%d\"",
project_edit_dialog_project_id);
g_print("SQL INSERT command: %s\n", sql_command);
int rc = sqlite3_exec(db, sql_command, NULL, 0, &error_message);
if (rc != SQLITE_OK) {
gchar *user_message = g_strdup_printf("Database error: %s\n", error_message);
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window_project_edit),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
user_message);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
sqlite3_free(error_message);
g_free(user_message);
return -1;
}
g_free(sql_command);
sqlite3_close(db);
// Reload the issue list
main_dialog_load_issue_list();
// Reload the project list
project_main_dialog_load_list();
// Close this dialog
project_edit_dialog_close();
return 0;
}
BOOL SetAlarmState(ALARM_LOCK_ACTION lock_type,ALARM_TYPE type,const char *value)
{
char sql[1024] = {0};
if(database_open()==FALSE) return FALSE;
switch(lock_type)
{
case ALARM_LOCK:
if(type == ALARM_TYPE_EMAIL){
sprintf(sql,"update alarmtable set F_STATE = 'c' where F_TYPE='email' and F_VALUE='%s'",value);
}else if(type == ALARM_TYPE_MOBILE){
sprintf(sql,"update alarmtable set F_STATE = 'c' where F_TYPE='mobile' and F_VALUE='%s'",value);
}
break;
case ALARM_UNLOCK:
if(type == ALARM_TYPE_EMAIL){
sprintf(sql,"update alarmtable set F_STATE = 'o' where F_TYPE='email' and F_VALUE='%s'",value);
}else if(type == ALARM_TYPE_MOBILE){
sprintf(sql,"update alarmtable set F_STATE = 'o' where F_TYPE='mobile' and F_VALUE='%s'",value);
}
break;
default:
return FALSE;
}
DEBUG_MSG("sql = %s",sql);
if(sqlite3_exec(db_user, sql,NULL,NULL,NULL)==SQLITE_OK){
database_close();
return TRUE;
}
database_close();
return FALSE;
}
int main (int argc, char ** args){
sqlite3 *db = database_open();
database_desc_table(db);
sqlite3_close(db);
return 0;
}
open_all()
{
sd_open(leave);
ss_open();
database_open();
pmfile_open(AUTOLOCK);
pmfile_setkey(1);
log_open(AUTOLOCK);
}
/*-------------------------------------------------------------------------*
* Open All Files
*-------------------------------------------------------------------------*/
open_all()
{
database_open();
sd_open(leave);
ss_open();
co_open();
getparms(0);
pmfile_open(READONLY);
prodfile_open(READONLY);
}
/*
*open all files
*/
open_all()
{
database_open();
sd_open(leave);
ss_open();
co_open();
oc_open();
od_open();
getparms(0);
}
void database_delete(struct Connection *conn, int id) {
struct Address addr = {.id=id, .set=0};
conn->db->rows[id] = addr;
}
void database_list(struct Connection *conn) {
for(int i=0; i<MAX_ROWS; ++i) {
struct Address *addr = &conn->db->rows[i];
if(addr->set)
address_print(addr);
}
}
int main(int argc, char *argv[]) {
if(argc < 3)
die("usage: a.out file action additional_params");
char *filename = argv[1];
char action = argv[2][0];
struct Connection *conn = database_open(filename, action);
int id=0;
if(argc > 3) id = atoi(argv[3]);
if(id >= MAX_ROWS) die("record id too high");
switch (action) {
case 'c':
database_create(conn);
database_write(conn);
break;
case 'g':
if(argc!=4) die("need an id for database_get()");
database_get(conn,id);
break;
case 's':
if(argc!=6) die("need id, name, email for database_set()");
database_set(conn,id,argv[4],argv[5]);
database_write(conn);
break;
case 'd':
if(argc!=4) die("need id to delete");
database_delete(conn,id);
database_write(conn);
break;
case 'l':
database_list(conn);
break;
default:
die("invalid action: c=create, g=get, s=set, d=delete, l=list");
}
database_close(conn);
return 0;
}
BOOL insertIntoCityIDTable(const char *name,const char *cityid)
{
char sql[1024] = {0};
if(database_open()==FALSE) return FALSE;
sprintf(sql,"insert into citytable values('%s','%s')",name,cityid);
int ret = sqlite3_exec(db, sql,NULL, NULL,NULL);
database_close();
if(ret == SQLITE_OK)
return TRUE;
return FALSE;
}
int main(int argc, char const * argv[]) {
const char * database_path;
void * buffer;
size_t size;
int ret = 0;
key_t key = ftok("database.sql", KEY_ID);
switch(argc) {
case 1: {
database_path = DATABASE_PATH_DEFAULT;
} break;
case 2: {
database_path = argv[1];
} break;
default: {
fprintf(stderr, "Usage: 'database.app [database_path]'.\n");
exit(EXIT_FAILURE);
}
}
database = database_open(database_path);
if(database == NULL) {
fprintf(stderr, "Can't open database.\n");
exit(EXIT_FAILURE);
}
server = smemory_make(key); // TODO: define 8080
if(server == NULL) {
fprintf(stderr, "Can't create the main connection.\n");
exit(EXIT_FAILURE);
}
signal(SIGINT, handle_int);
while(!ret) {
if(smemory_read(server, &buffer, &size)) {
ret = handle(buffer, size);
} else {
fprintf(stderr, "Error while reading from shared memory.\n");
ret = -1;
}
}
smemory_remove(server);
database_close(database);
return ret == -1 ? EXIT_FAILURE : EXIT_SUCCESS;
}
BOOL isUserMobileNumberValid(const char *mobile_number)
{
int row_num = 0,column_num = 0;
char sql[1024] = {0};
char **azResult;
if(database_open()==FALSE) return FALSE;
sprintf(sql,"select * from alarmtable where F_TYPE='mobile' and F_VALUE='%s' and F_STATE='o'",mobile_number);
sqlite3_get_table(db_user,sql, &azResult, &row_num, &column_num, NULL);
if(row_num>0){
sqlite3_free_table(azResult);
database_close();
return TRUE;
}
database_close();
return FALSE;
}
BOOL GetCityIDByName(const char *name,char *cityid)
{
char **azResult;
int row_num = 0,column_num = 0;
char sql[1024] = {0};
if(database_open() == FALSE) return FALSE;
sprintf(sql,"select F_CityID from citytable where F_NAME='%s'",name);
sqlite3_get_table(db,sql, &azResult, &row_num, &column_num, NULL);
if(row_num>=1){
strcpy(cityid,azResult[1]);
sqlite3_free_table(azResult);
database_close();
return TRUE;
}
database_close();
return FALSE;
}
/*
*open all files
*/
open_all()
{
database_open();
sd_open(leave);
ss_open();
co_open();
picker_open(AUTOLOCK);
picker_setkey(0);
picker_order_open(AUTOLOCK);
picker_order_setkey(0);
return 0;
}
int project_main_dialog_load_list()
{
// Clear model
GtkListStore *store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(project_main_treeview)));
gtk_list_store_clear(store);
// Query database and fill the model
char *error_message = NULL;
sqlite3 *db = database_open();
if (db == NULL) {
g_print("Can't open database: %s\n", sqlite3_errmsg(db));
database_close();
return -1;
}
const gchar sql_command[] = "SELECT p.project_id, p.name, p.status, "
"(SELECT COUNT(*) FROM issue i WHERE i.project_id = p.project_id) "
"FROM project p "
"ORDER BY p.name, p.status";
g_print("query command: %s\n", sql_command);
int rc = sqlite3_exec(db, sql_command, project_main_dialog_issue_list_query_callback, 0, &error_message);
if (rc != SQLITE_OK) {
g_print("SQL error: %s\n", error_message);
sqlite3_free(error_message);
}
database_close();
return 0;
}
int main(void) {
EXCEPTION *e = exception_new();
printf ( "NEW\n" );
DATABASE *db = database_new();
database_setException(db, e);
exception_throw(e);
printf ( "PARAM\n" );
database_setHost(db, "localhost");
database_setName(db, "template1");
database_setUser(db, "postgres");
database_setPassword(db, "postgres");
printf ( "OPEN\n" );
database_open(db);
exception_throw(e);
printf ( "VERSION" );
char *ver = database_getVersion(db);
exception_throw(e);
printf ( " (%s)\n", ver );
free(ver);
printf ( "RANDOM" );
int rnd = database_getRandom(db);
exception_throw(e);
printf ( " (%d)\n", rnd );
printf ( "CLOSE\n" );
database_close(db);
exception_throw(e);
printf ( "FREE\n" );
database_free(db);
exception_throw(e);
exception_free(e);
return 0;
}
BOOL DeleteByEmailOrMobile(ALARM_TYPE type,const char *value)
{
char sql[1024] = {0};
if(database_open()==FALSE) return FALSE;
switch(type)
{
case ALARM_TYPE_EMAIL:
sprintf(sql,"delete from alarmtable where F_TYPE='email' and F_VALUE='%s'",value);
break;
case ALARM_TYPE_MOBILE:
sprintf(sql,"delete from alarmtable where F_TYPE='mobile' and F_VALUE='%s'",value);
break;
default:
return FALSE;
}
if(sqlite3_exec(db_user, sql,NULL,NULL,NULL)==SQLITE_OK){
database_close();
return TRUE;
}
database_close();
return FALSE;
}
int main(void) {
EXCEPTION *e = exception_new();
printf ( "NEW\n" );
DATABASE *db = database_new();
database_setException(db, e);
exception_throw(e);
printf ( "PARAM\n" );
database_setName(db, "sqlite.db");
printf ( "OPEN\n" );
database_open(db);
exception_throw(e);
printf ( "VERSION" );
char *ver = database_getVersion(db);
exception_throw(e);
printf ( " (%s)\n", ver );
free(ver);
printf ( "RANDOM" );
int rnd = database_getRandom(db);
exception_throw(e);
printf ( " (%d)\n", rnd );
printf ( "CLOSE\n" );
database_close(db);
exception_throw(e);
printf ( "FREE\n" );
database_free(db);
exception_throw(e);
exception_free(e);
return 0;
}
/* -------------------------------------------------------------------------- */
int
server_init(server_t** server, const char* database)
{
if(server == NULL || database == NULL)
return ERROR_INVALID_ARGUMENTS;
/* request memory for server */
if(requestMemory((void**)server, sizeof(server_t)) != ERROR_OK)
return ERROR_MEMORY;
(*server)->db = NULL;
/* open database connection */
database_handle_t *db = NULL;
int retval = database_open(&db, database);
if(retval != ERROR_OK){
//freeMemory(*server);
//freeMemory(db);
return retval;
}
(*server)->db = db;
return ERROR_OK;
}
void GetEmailList(void)
{
if(database_open()==FALSE) return;
char *sql = "select F_VALUE from alarmtable where F_TYPE = 'email' and F_STATE = 'o'";
int row_num = 0,column_num = 0,i = 0;
char **azResult;
sqlite3_get_table(db_user,sql, &azResult, &row_num, &column_num, NULL);
memset(g_email_list,0,sizeof(g_email_list));
if(row_num >= 1){
for(i = 1;i<row_num+1;i++)
{
strcat(g_email_list,azResult[ i*column_num]);
strcat(g_email_list,",");
}
g_email_list[strlen(g_email_list)-1] = '\0';
DEBUG_MSG("emailist = %s\n",g_email_list);
}
else{
strcpy(g_email_list,"_NULL_");
}
sqlite3_free_table(azResult);
database_close();
}
int project_edit_dialog_load_data()
{
g_print("project_edit_dialog_load_data()\n");
char *error_message = 0;
sqlite3 *db = database_open();
if (db == NULL) {
g_print("Can't open database: %s\n", sqlite3_errmsg(db));
sqlite3_close(db);
return -1;
}
gchar *sql_command = g_strdup_printf("SELECT name, status "
"FROM project "
"WHERE project_id = \"%d\"", project_edit_dialog_project_id);
g_print("SQL query command: %s\n", sql_command);
int rc = sqlite3_exec(db, sql_command, project_edit_data_query_callback, 0, &error_message);
if (rc != SQLITE_OK) {
g_print("SQL error: %s\n", error_message);
sqlite3_free(error_message);
}
sqlite3_close(db);
g_free(sql_command);
return 0;
}
BOOL insertIntoAlarmTable(ALARM_TYPE type,const char *value)
{
char sql[1024] = {0};
if(database_open()==FALSE) return FALSE;
switch(type){
case ALARM_TYPE_EMAIL:
DEBUG_MSG("email = %s\n",value);
sprintf(sql,"insert into alarmtable values('email','%s','o')",value);
break;
case ALARM_TYPE_MOBILE:
DEBUG_MSG("mobile = %s \n",value);
sprintf(sql,"insert into alarmtable values('mobile','%s','o')",value);
break;
default:
DEBUG_MSG("default = %s\n",value);
sprintf(sql,"insert into alarmtable values('email','%s','o')",value);
break;
}
int ret = sqlite3_exec(db_user, sql,NULL, NULL,NULL);
database_close();
if(ret == SQLITE_OK)
return TRUE;
return FALSE;
}
void database_create(struct Connection *conn)
{
int i = 0;
for(i = 0; i < MAX_ROWS; i++) {
// make a prototype to initialize the database
struct Address addr = {.id = i, .set = 0};
// then assign it to conn
conn->db->rows[i] = addr;
}
printf("got to bottom of database create");
}
void database_set(struct Connection *conn, int id, const char *name,
const char *email)
{
struct Address *addr = &conn->db->rows[id];
if(addr->set) die("Already set, delete it first");
addr->set = 1;
// WARNING FIX THIS
char *res = strncpy(addr->name, name, MAX_DATA);
// demonstrate that strncpy bug
if(!res) die("Name copy failed");
res = strncpy(addr->email, email, MAX_DATA);
if(!res) die("Email copy failed");
}
void database_get(struct Connection *conn, int id)
{
struct Address *addr = &conn->db->rows[id];
if(addr->set) {
address_print(addr);
} else {
die("ID is not set");
}
}
void database_delete(struct Connection *conn, int id)
{
struct Address addr = {.id = id, .set = 0};
conn->db->rows[id] = addr;
}
void database_list(struct Connection *conn)
{
int i = 0;
struct Database *db = conn->db;
for(i = 0; i < MAX_ROWS; i++) {
struct Address *cur = &db->rows[i];
if(cur->set) {
address_print(cur);
}
}
}
int main(int argc, char *argv[])
{
if(argc < 3) die("USAGE: ex17 <dbfile> <action> [action params]");
char *filename = argv[1];
char action = argv[2][0];
struct Connection *conn = database_open(filename, action);
int id = 0;
if(argc > 3) id = atoi(argv[3]);
if(id >= MAX_ROWS) die("There's not that many records.");
switch(action) {
case 'c':
database_create(conn);
database_write(conn);
break;
case 'g':
if(argc != 4) die("Need an id to get");
database_get(conn, id);
break;
case 's':
if(argc != 6) die("Need id, name, email to set");
database_set(conn, id, argv[4], argv[5]);
database_write(conn);
break;
case 'd':
if(argc != 4) die("Need id to delete");
database_delete(conn, id);
database_write(conn);
break;
case 'l':
database_list(conn);
break;
default:
die("Invalid action, only: c=create, g=get, s=set, d=del, l=list");
}
database_close(conn);
return 0;
}
void pop3(FILE *client, const char *dbfile)
{
struct database db;
if (database_open(&db, dbfile) != 0) {
RESPOND(client, "%s", "-ERR");
fclose(client);
return;
} else {
RESPOND(client, "+OK %s", "POP3 server ready");
}
char user[512] = {0};
char pass[512] = {0};
char email[512] = {0};
char pass1[512] = {0};
char pass2[512] = {0};
char firstname[512] = {0};
char lastname[512] = {0};
struct message_email *messages = NULL;
struct message_user *messages_user = NULL;
while (!feof(client)) {
char line[512];
printf("Client message: %s", line);
if(fgets(line, sizeof(line), client)){}
char command[5] = {line[0], line[1], line[2], line[3]};
if(strcmp(command,"CREA") == 0){
int i;
int count = 0;
int errorCreate = 0;
if (strlen(line) > 5) {
char *a = line + 5, *b = email,*c = firstname,*d = lastname,*e = pass1,*f = pass2;
for(i = 0;i<strlen(line);i++)
if(line[i] =='+')
count++;
if(count==5){
while (*a!='+')
*(b++) = *(a++);
*b = '\0';
a++;
while (*a!='+')
*(c++) = *(a++);
*c = '\0';
a++;
while (*a!='+')
*(d++) = *(a++);
*d = '\0';
a++;
while (*a!='+')
*(e++) = *(a++);
*e = '\0';
a++;
while (*a!='+')
*(f++) = *(a++);
*f = '\0';
i=0;
messages_user = database_list_user_signin(&db,email,pass1);
for(struct message_user *m = messages_user; m; m = m->next){
i++;
}
if(i!=0){
errorCreate = 1;
} else
errorCreate = 0;
if(!errorCreate){
database_send_user(&db,email,firstname,lastname,pass1,pass2);
RESPOND(client,"%s","+OK");
}else RESPOND(client,"%s","-ER");
}
}
}else if (strcmp(command, "USER") == 0) {
if (strlen(line) > 5) {
char *a = line + 5, *b = user;
while (*a!='+')
*(b++) = *(a++);
*b = '\0';
RESPOND(client, "%s", "+OKUSER");
} else {
RESPOND(client, "%s", "-ERRUSER");
}
printf("|%s|\n",user);
messages = database_list_email(&db, user);
} else if (strcmp(command, "PASS") == 0) {
if (strlen(line) > 5) {
char *a = line + 5, *b = pass;
while (*a!='+')
*(b++) = *(a++);
*b = '\0';
if(!user[0])
RESPOND(client,"%s","-ERR enter user first");
else{
messages_user = database_list_user_signin(&db,user,pass);
int i = 0;
for(struct message_user *m = messages_user; m; m = m->next){
i++;
}
if(i!=1){
RESPOND(client,"%s","-ER");
} else
RESPOND(client,"%s","+OK");
}
}
} else if (strcmp(command, "FORG") == 0) {
if (strlen(line) > 5) {
char *a = line + 5, *b = pass;
while (*a!='+')
*(b++) = *(a++);
*b = '\0';
if(!user[0])
RESPOND(client,"%s","-ERR enter user first");
else{
messages_user = database_list_user_forgotpassword(&db,user,pass);
int i = 0;
for(struct message_user *m = messages_user; m; m = m->next){
i++;
RESPOND(client, "email: %s\npassword: %s", m->email, m->pass1);
}
if(i!=1){
RESPOND(client,"%s","Wrong level 2 password.");
}
}
}
}else if (strcmp(command, "STAT") == 0) {
int count = 0, size = 0;
for (struct message_email *m = messages; m; m = m->next) {
count++;
size += m->length;
}
RESPOND(client, "+OK %d %d", count, size);
} else if (strcmp(command, "LIST") == 0) {
int temp1=0;
for (struct message_email *m = messages; m; m = m->next){
temp1++;
char temp[1000];
char tempuser[1000];
int i=0;
while(m->content[i]!='\n'){
temp[i] = m->content[i];
i++;
}
temp[i]='\0';
i=0;
while(m->user[i]!='\n' && m->user[i]!='\r'){
tempuser[i] = m->user[i];
i++;
}
tempuser[i]='\0';
RESPOND(client, "%-5d | %-30s | %-30s", m->id, temp,tempuser);
}
if(temp1==0)
RESPOND(client,"%s","inbox is empty!");
}else if (strcmp(command, "RETR") == 0) {
int id = atoi(line + 4);
int found = 0;
for (struct message_email *m = messages; m; m = m->next)
if (m->id == id) {
found = 1;
RESPOND(client, " - Mail from: %s", m->user);
RESPOND(client, " - Subject: %s",m->content);
}
RESPOND(client, "%s", found ? "." : "-ERR");
} else if (strcmp(command, "DELE") == 0) {
int id = atoi(line + 4);
int found = 0;
for (struct message_email *m = messages; m; m = m->next) {
if (m->id == id) {
found = 1;
RESPOND(client, "%s", "+OK");
database_delete_email(&db, id);
break;
}
}
if (!found)
RESPOND(client, "%s", "-ERRor");
} else if (strcmp(command, "TOP ") == 0) {
int id, lines;
sscanf(line, "TOP %d %d", &id, &lines);
int found = 0;
for (struct message_email *m = messages; m; m = m->next) {
if (m->id == id) {
RESPOND(client, "%s", "+OK");
found = 1;
char *p = m->content;
while (*p && memcmp(p, "\r\n\r\n", 4) != 0) {
fputc(*p, client);
p++;
}
if (*p) {
p += 4;
int line = 0;
while (*p && line < lines) {
if (*p == '\n')
line++;
p++;
}
}
break;
}
}
RESPOND(client, "%s", found ? "\r\n." : "-ERR");
} else if (strcmp(command, "QUIT") == 0) {
RESPOND(client, "%s", "+OK");
break;
} else {
RESPOND(client, "%s", "-ERR");
}
}
while (messages) {
struct message_email *dead = messages;
messages = messages->next;
free(dead);
}
fclose(client);
database_close(&db);
}
main()
{
register struct pw_item *i;
register struct st_item *s;
register long k, errors;
long pid, status;
char command[80];
putenv("_=orphan_picks");
chdir(getenv("HOME"));
database_open();
ss_open();
co_open();
oc_open();
od_open();
if (sp->sp_sku_support == 'n') leave(0);
errors = 0;
tmp_name(fd_name);
fd = fopen(fd_name, "w");
if (fd == 0) krash("main", "open temp", 1);
if (sp->sp_sku_support == 'y') /* only when sku support */
{
for (k = 0, i = pw; k < coh->co_prod_cnt; k++, i++)
{
if (i->pw_lines_to_go <= 0) continue; /* has no picks */
s = mod_lookup(k + 1); /* find in sku table */
if (s) continue; /* module has a sku */
fprintf(fd, "No SKU Assigned To Module %d Has %d Picks\n",
k + 1, i->pw_lines_to_go);
errors++;
}
}
#ifdef DEBUG
fprintf(stderr, "errors=%d\n", errors);
#endif
fprintf(fd, "\n\n");
pick_setkey(1);
begin_work();
while (!pick_next(op_rec, NOLOCK))
{
#ifdef DEBUG
fprintf(stderr, "pl=%d on=%d mod=%d flag=%x\n",
op_rec->pi_pl, op_rec->pi_on, op_rec->pi_mod, op_rec->pi_flags);
#endif
commit_work();
begin_work();
if (op_rec->pi_flags & VALIDATED) continue;
fprintf(fd,
"Pickline: %2d Order: %7.*d Mod: %5d SKU: %-15.15s Quan: %3d\n",
op_rec->pi_pl, rf->rf_on, op_rec->pi_on, op_rec->pi_mod,
op_rec->pi_sku, op_rec->pi_ordered);
errors++;
}
commit_work();
fclose(fd);
if (errors)
{
tmp_name(ed_name);
if (fork() == 0)
{
execlp("prft", "prft", fd_name, ed_name, "sys/report/orphan_picks.h", 0);
krash("main", "load prft", 1);
}
pid = wait(&status);
if (!pid || status) krash("main", "prft failed", 1);
sprintf(command, "%s %s", getenv("LPR"), fd_name);
}
else unlink(fd_name);
leave(0);
}
int project_edit_dialog_save_data()
{
g_print("project_edit_dialog_save_data()\n");
GtkTreeIter iter_status;
// Check values
if (g_utf8_strlen(gtk_entry_get_text(GTK_ENTRY(project_edit_entry_name)), -1) <= 0) {
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window_project_edit),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"The project name is needed.");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return -1;
}
if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(project_edit_combo_status), &iter_status)) {
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window_project_edit),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"The status is needed.");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return -1;
}
// Status
gchar *status_id;
GtkTreeModel *status_model = gtk_combo_box_get_model(GTK_COMBO_BOX(project_edit_combo_status));
gtk_tree_model_get(status_model, &iter_status, 1, &status_id, -1);
g_print("Selected status: %s\n", status_id);
// Mount SQL command
char *error_message = 0;
sqlite3 *db = database_open();
if (db == NULL) {
g_print("Can't open database: %s\n", sqlite3_errmsg(db));
sqlite3_close(db);
return -1;
}
gchar *sql_command = g_strdup_printf("UPDATE project "
"SET name = \"%s\", "
"status = \"%s\" "
"WHERE project_id = \"%d\"",
gtk_entry_get_text(GTK_ENTRY(project_edit_entry_name)),
status_id,
project_edit_dialog_project_id);
g_print("SQL INSERT command: %s\n", sql_command);
int rc = sqlite3_exec(db, sql_command, NULL, 0, &error_message);
if (rc != SQLITE_OK) {
gchar *user_message = g_strdup_printf("Database error: %s\n", error_message);
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window_project_edit),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
user_message);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
sqlite3_free(error_message);
sqlite3_free(user_message);
}
g_free(sql_command);
sqlite3_close(db);
// Reload the list
project_main_dialog_load_list();
// Reload issue list
main_dialog_load_issue_list();
// Close this dialog
project_edit_dialog_close();
return 0;
}
int issue_new_dialog_save_data()
{
g_print("issue_new_dialog_save_data()\n");
GtkTreeIter iter_project;
GtkTreeIter iter_status;
GtkTreeIter iter_os;
GtkTreeIter iter_priority;
//GtkWidget *text_view = NULL;
// Check values
if (g_utf8_strlen(gtk_entry_get_text(GTK_ENTRY(entry_summary)), -1) <= 0) {
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window_issue_new),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"The summary is needed.");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return -1;
}
if (g_utf8_strlen(gtk_entry_get_text(GTK_ENTRY(entry_version)), -1) <= 0) {
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window_issue_new),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"The version is needed.");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return -1;
}
if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo_project), &iter_project)) {
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window_issue_new),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"The project is needed.");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return -1;
}
if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo_priority), &iter_priority)) {
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window_issue_new),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"The priority is needed.");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return -1;
}
if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo_os), &iter_os)) {
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window_issue_new),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"The operating system is needed.");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return -1;
}
if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo_status), &iter_status)) {
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window_issue_new),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"The status is needed.");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return -1;
}
// Project value
int project_id;
GtkTreeModel *project_model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo_project));
gtk_tree_model_get(project_model, &iter_project, 1, &project_id, -1);
g_print("Selected Project: %d\n", project_id);
// Priority value
int priority_id;
GtkTreeModel *priority_model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo_priority));
gtk_tree_model_get(priority_model, &iter_priority, 1, &priority_id, -1);
g_print("Selected priority: %d\n", priority_id);
// OS value
int os_id;
GtkTreeModel *os_model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo_os));
gtk_tree_model_get(os_model, &iter_os, 1, &os_id, -1);
g_print("Selected os: %d\n", os_id);
// Project value
gchar *status_id;
GtkTreeModel *status_model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo_status));
gtk_tree_model_get(status_model, &iter_status, 1, &status_id, -1);
g_print("Selected status: %s\n", status_id);
// Description value
GtkTextIter iter_start;
GtkTextIter iter_end;
gtk_text_buffer_get_start_iter(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view)), &iter_start);
gtk_text_buffer_get_end_iter(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view)), &iter_end);
g_print("Descrição: %s\n",
gtk_text_buffer_get_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view)),
&iter_start,
&iter_end,
FALSE));
// Mount SQL command
char *error_message = 0;
sqlite3 *db = database_open();
if (db == NULL) {
g_print("Can't open database: %s\n", sqlite3_errmsg(db));
sqlite3_close(db);
return -1;
}
gchar *sql_command = g_strdup_printf("INSERT INTO issue "
"(summary, project_id, priority, status, platform, version, description) "
"VALUES (\"%s\", \"%d\", \"%d\", \"%s\", \"%d\", \"%s\", \"%s\")",
gtk_entry_get_text(GTK_ENTRY(entry_summary)),
project_id,
priority_id,
status_id,
os_id,
gtk_entry_get_text(GTK_ENTRY(entry_version)),
gtk_text_buffer_get_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view)),
&iter_start,
&iter_end,
FALSE));
g_print("SQL INSERT command: %s\n", sql_command);
int rc = sqlite3_exec(db, sql_command, NULL, 0, &error_message);
if (rc != SQLITE_OK) {
gchar *user_message = g_strdup_printf("Database error: %s\n", error_message);
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window_issue_new),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
user_message);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
sqlite3_free(error_message);
sqlite3_free(user_message);
}
g_free(sql_command);
sqlite3_close(db);
// Reload the list
main_dialog_load_issue_list();
// Close this dialog
issue_new_dialog_close();
return 0;
}
main()
{
register long k;
unsigned char t, incode[2], ans[2], yn[2], again[2];
unsigned char timestr[30], datetime[15], intime[20];
long systime;
long pid, status;
putenv("_=transac_output");
chdir(getenv("HOME"));
open_all();
fix(transac_output);
sd_screen_off();
sd_clear_screen();
sd_text(transac_output);
sd_screen_on();
sd_prompt(&fld[0], 0);
while(1)
{
for (k = 15; k <= 20; k++)
{
sd_cursor(0, k, 1);
sd_clear_line();
}
while(1)
{
memset(incode, 0, 2);
t = sd_input(&fld[0], 0, 0, incode, 0);
if(t == EXIT) leave();
if(t == UP_CURSOR) continue;
if (!*incode) break;
*incode = tolower(*incode);
if (*incode != 'c' && *incode != 'd' &&
*incode != 'p' && *incode != 'e')
{
eh_post(ERR_CODE, incode);
continue;
}
break;
}
if (*incode == 'p')
{
if (sp->sp_to_flag != 'y' && sp->sp_to_flag != 'b')
{
eh_post(LOCAL_MSG, "No Transaction File Feature");
continue;
}
sd_wait();
if((pid = fork()) == 0)
{
ss_close();
execlp("transac_short_rpt", "transac_short_rpt", 0);
exit(1);
}
else pid = wait(&status);
if (pid > 0 && !status) eh_post(ERR_CONFIRM, "Short Printing");
else eh_post(CRASH_MSG, "tranac_short_rpt failed");
continue;
}
if (*incode == 'e')
{
if (sp->sp_to_flag != 'y' && sp->sp_to_flag != 'b')
{
eh_post(LOCAL_MSG, "No Transaction File Feature");
continue;
}
while(1)
{
memset(ans, 0, 2); /* are you sure response */
memset(yn, 0, 2);
t = sd_input(&fld[5],sd_prompt(&fld[5],0), 0, yn, 0);
if (t == EXIT) leave();
if (t == UP_CURSOR) break;
*ans = code_to_caps(*yn);
if(*ans != 'y' && *ans != 'n')
{
eh_post(ERR_YN,0);
continue;
}
if(*ans == 'y')
{
eh_post(LOCAL_MSG, "Purging Transaction File");
database_open();
xt_open();
transaction_setkey(0);
begin_work();
while (!transaction_next(&xt, LOCK))
{
transaction_delete();
commit_work();
begin_work();
}
commit_work();
xt_close();
database_close();
sp->sp_to_count = 0;
eh_post(PURGE_TRANS, 0);
}
break;
} /* end while(1) */
continue;
} /* end if */
if (*incode == 'c' || *incode == 'd')
{
if (sp->sp_to_mode != 0x20 || sp->sp_oi_mode == *incode) /* F071395 */
{
eh_post(LOCAL_MSG, "Device/Port In Use");
continue;
}
}
if (*incode == 'd')
{
while(1)
{
memset(ans, 0, 2);
memset(yn, 0, 2);
t = sd_input(&fld[1],sd_prompt(&fld[1],0), 0, yn, 0);
if (t == EXIT) leave();
if (t == UP_CURSOR) break;
*ans = code_to_caps(*yn);
if(*ans != 'y' && *ans != 'n')
{
eh_post(ERR_YN,0);
continue;
}
break;
}
if (t == UP_CURSOR) continue;
if (*ans == 'n') continue; /* abort diskette in */
}
while(1)
{
memset(again, 0, 2); /* retransmit response */
memset(yn, 0, 2);
t = sd_input(&fld[2],sd_prompt(&fld[2],0), 0, yn, 0);
if (t == EXIT) leave();
if (t == UP_CURSOR) break;
*again = code_to_caps(*yn);
if (*again != 'y' && *again != 'n')
{
eh_post(ERR_YN, 0);
continue;
}
break;
}
if (t == UP_CURSOR) continue;
while(1)
{
memset(ans, 0, 2); /* purge response */
memset(yn, 0, 2);
t = sd_input(&fld[3],sd_prompt(&fld[3],0), 0, yn, 0);
if(t == EXIT) leave();
if(t == UP_CURSOR) break;
*ans = code_to_caps(*yn);
if(*ans != 'y' && *ans != 'n')
{
eh_post(ERR_YN,0);
continue;
}
break;
}
if(*ans == 'y')
{
sd_prompt(&fld[4],0);
systime = time(0) - sp->sp_purge_window;
strcpy(timestr, ctime(&systime));
timestr[24] = 0;
sd_cursor(0,18,25);
sd_text("Default Date/Time:");
sd_cursor(0,18,54);
sd_text(×tr[4]);
sd_cursor(0,20,25);
sd_text("Format is:");
sd_cursor(0,20,54);
sd_text("mm/dd/yyyy hh:mm:ss");
while(1)
{
t = sd_input(&fld[4], 0, 0, intime, 0);
if(t == EXIT) leave();
if(t == UP_CURSOR) break;
if(*intime != 0)
{
if(!time_convert(intime, &systime))
{
eh_post(ERR_TIME, intime);
continue;
}
}
eh_post(LOCAL_MSG, "Purging Orders");
if ((pid = fork()) == 0)
{
sprintf(datetime, "%d", systime);
ss_close();
execlp("order_purge", "order_purge", datetime, 0);
exit(1);
}
else pid = wait(&status);
if (pid > 0 && !status) eh_post(ERR_CONFIRM, "Order purge");
else eh_post(CRASH_MSG, "order_purge failed");
break;
}
if (t == UP_CURSOR) continue;
}
if (*again == 'n') /* transmit current file */
{
eh_post(LOCAL_MSG, "Extracting Transactions");
if ((pid = fork()) == 0)
{
ss_close();
execlp("transac_copy", "transac_copy", 0);
exit(1);
}
else pid = wait(&status);
if (pid < 0 || status)
{
eh_post(LOCAL_MSG, "transac_copy failed");
continue;
}
eh_post(ERR_CONFIRM, "Transaction File");
}
/*
* Start Transaction Output Operations
*/
if (*incode == 'c') /* comm output */
{
if (sp->sp_commo_trans_out == 'n')
{
eh_post(LOCAL_MSG, "No Communication Feature");
continue;
}
eh_post(LOCAL_MSG, "Sending Transactions");
sd_close();
sp->sp_to_mode = 'c';
if (fork() == 0)
{
if (sp->sp_commo_trans_out == 'k')
{
ss_close();
execlp("com_kermit_out", "com_kermit_out", 0);
}
else
{
ss_close();
execlp("comsend", "comsend", 0);
}
ss_open();
sd_open();
sp->sp_to_mode = 0x20;
eh_post(LOCAL_MSG, "Program Not Found");
continue;
}
pid = wait(&status);
sp->sp_to_mode = 0x20;
sd_open();
if (pid < 0 || status)
{
eh_post(LOCAL_MSG, "Communications Failed");
}
else eh_post(ERR_CONFIRM, "Transactions Output");
continue;
}
if (*incode == 'd')
{
sd_wait();
sp->sp_to_mode = 'd';
sprintf(message, command);
status = system(message);
sp->sp_to_mode = 0x20;
if (status) eh_post(LOCAL_MSG, "Diskette output failed");
else eh_post(ERR_CONFIRM, "Tranaction Output");
}
}
}
