academy-chauffeurs - getsetrm.go

     1  package main
     2  
     3  import (
     4  	"database/sql"
     5  	"strings"
     6  )
     7  
     8  func (c *Calls) GetDriver(id int64, d *Driver) error {
     9  	c.mu.Lock()
    10  	defer c.mu.Unlock()
    11  	err := c.statements[ReadDriver].QueryRow(id).Scan(&d.Name, &d.RegistrationNumber, &d.PhoneNumber, &d.Pos, &d.Show)
    12  	if err == sql.ErrNoRows {
    13  		return nil
    14  	}
    15  	d.ID = id
    16  	return err
    17  }
    18  
    19  func (c *Calls) GetClient(id int64, cl *Client) error {
    20  	c.mu.Lock()
    21  	defer c.mu.Unlock()
    22  	err := c.statements[ReadClient].QueryRow(id).Scan(&cl.CompanyID, &cl.Name, &cl.PhoneNumber, &cl.Reference, &cl.Email, &cl.Address)
    23  	if err == sql.ErrNoRows {
    24  		return nil
    25  	}
    26  	cl.ID = id
    27  	return err
    28  }
    29  
    30  func (c *Calls) GetCompany(id int64, cy *Company) error {
    31  	c.mu.Lock()
    32  	defer c.mu.Unlock()
    33  	err := c.statements[ReadCompany].QueryRow(id).Scan(&cy.Name, &cy.Address, &cy.Colour)
    34  	if err == sql.ErrNoRows {
    35  		return nil
    36  	}
    37  	cy.ID = id
    38  	return err
    39  }
    40  
    41  func (c *Calls) GetEvent(id int64, e *Event) error {
    42  	c.mu.Lock()
    43  	defer c.mu.Unlock()
    44  	err := c.statements[ReadEvent].QueryRow(id).Scan(&e.DriverID, &e.ClientID, &e.Start, &e.End, &e.InvoiceNote, &e.InvoiceFrom, &e.InvoiceTo, &e.Other, &e.ClientReference, &e.Booker, &e.FlightTime, &e.Profile, &e.From, &e.To)
    45  	if err == sql.ErrNoRows {
    46  		return nil
    47  	}
    48  	e.ID = id
    49  	return err
    50  }
    51  
    52  type SetDriverResponse struct {
    53  	Errors                          bool
    54  	ID                              int64
    55  	NameError, RegError, PhoneError string
    56  }
    57  
    58  func (c *Calls) SetDriver(d Driver, resp *SetDriverResponse) error {
    59  	if d.Name == "" {
    60  		resp.Errors = true
    61  		resp.NameError = "Name Required"
    62  	}
    63  	if d.RegistrationNumber == "" {
    64  		resp.Errors = true
    65  		resp.RegError = "Registration Number Required"
    66  	}
    67  	var err error
    68  	if !resp.Errors {
    69  		c.mu.Lock()
    70  		defer c.mu.Unlock()
    71  		if d.ID == 0 {
    72  			r, e := c.statements[CreateDriver].Exec(d.Name, d.RegistrationNumber, d.PhoneNumber)
    73  			if e == nil {
    74  				resp.ID, e = r.LastInsertId()
    75  				if e == nil {
    76  					_, e = c.statements[SetDriverShowPos].Exec(true, resp.ID, resp.ID)
    77  				}
    78  			}
    79  			err = e
    80  		} else {
    81  			resp.ID = d.ID
    82  			_, err = c.statements[UpdateDriver].Exec(d.Name, d.RegistrationNumber, d.PhoneNumber, d.ID)
    83  		}
    84  	}
    85  	return err
    86  }
    87  
    88  type SetClientResponse struct {
    89  	Errors                                                          bool
    90  	ID                                                              int64
    91  	NameError, CompanyError, PhoneError, ReferenceError, EmailError string
    92  }
    93  
    94  func (c *Calls) SetClient(cl Client, resp *SetClientResponse) error {
    95  	if cl.Name == "" {
    96  		resp.Errors = true
    97  		resp.NameError = "Name Required"
    98  	}
    99  	if cl.CompanyID == 0 {
   100  		resp.Errors = true
   101  		resp.CompanyError = "Company Required"
   102  	} else {
   103  		var cy Company
   104  		if err := c.GetCompany(cl.CompanyID, &cy); err != nil {
   105  			return err
   106  		}
   107  		if cy.ID == 0 {
   108  			resp.Errors = true
   109  			resp.CompanyError = "Valid Company Required"
   110  		}
   111  	}
   112  	if cl.Reference == "" {
   113  		resp.Errors = true
   114  		resp.ReferenceError = "Reference Required"
   115  	}
   116  	var err error
   117  	if !resp.Errors {
   118  		c.mu.Lock()
   119  		defer c.mu.Unlock()
   120  		if cl.ID == 0 {
   121  			r, e := c.statements[CreateClient].Exec(cl.CompanyID, cl.Name, cl.PhoneNumber, cl.Reference, cl.Email, cl.Address)
   122  			if e == nil {
   123  				resp.ID, e = r.LastInsertId()
   124  			}
   125  			err = e
   126  		} else {
   127  			resp.ID = cl.ID
   128  			_, err = c.statements[UpdateClient].Exec(cl.CompanyID, cl.Name, cl.PhoneNumber, cl.Reference, cl.Email, cl.Address, cl.ID)
   129  		}
   130  	}
   131  	return err
   132  }
   133  
   134  type SetCompanyResponse struct {
   135  	Errors                  bool
   136  	ID                      int64
   137  	NameError, AddressError string
   138  }
   139  
   140  func (c *Calls) SetCompany(cy Company, resp *SetCompanyResponse) error {
   141  	if cy.Name == "" {
   142  		resp.Errors = true
   143  		resp.NameError = "Name Required"
   144  	}
   145  	if cy.Address == "" {
   146  		resp.Errors = true
   147  		resp.AddressError = "Address Required"
   148  	}
   149  	var err error
   150  	if !resp.Errors {
   151  		c.mu.Lock()
   152  		defer c.mu.Unlock()
   153  		if cy.ID == 0 {
   154  			r, e := c.statements[CreateCompany].Exec(cy.Name, cy.Address, cy.Colour)
   155  			if e == nil {
   156  				resp.ID, e = r.LastInsertId()
   157  			}
   158  			err = e
   159  		} else {
   160  			resp.ID = cy.ID
   161  			_, err = c.statements[UpdateCompany].Exec(cy.Name, cy.Address, cy.Colour, cy.ID)
   162  		}
   163  	}
   164  	return err
   165  }
   166  
   167  type SetEventResponse struct {
   168  	Errors                                                  bool
   169  	ID                                                      int64
   170  	DriverError, ClientError, TimeError, FromError, ToError string
   171  }
   172  
   173  func (c *Calls) SetEvent(e Event, resp *SetEventResponse) error {
   174  	if e.DriverID > 0 {
   175  		var d Driver
   176  		if err := c.GetDriver(e.DriverID, &d); err != nil {
   177  			return err
   178  		}
   179  		if d.ID == 0 {
   180  			e.DriverID = 0
   181  			resp.Errors = true
   182  			resp.DriverError = "Valid Driver Required"
   183  		}
   184  	}
   185  	if e.ClientID == 0 {
   186  		resp.Errors = true
   187  		resp.ClientError = "Client Required"
   188  	} else {
   189  		var cl Client
   190  		if err := c.GetClient(e.ClientID, &cl); err != nil {
   191  			return err
   192  		}
   193  		if cl.ID == 0 {
   194  			resp.Errors = true
   195  			resp.ClientError = "Valid Client Required"
   196  		}
   197  	}
   198  	if e.Start == 0 || e.End == 0 {
   199  		resp.Errors = true
   200  		resp.TimeError = "Invalid Time(s)"
   201  	} else if e.DriverID != 0 {
   202  		var exists int64
   203  		c.mu.Lock()
   204  		err := c.statements[EventOverlap].QueryRow(e.ID, e.DriverID, e.Start, e.End).Scan(&exists)
   205  		c.mu.Unlock()
   206  		if err != nil {
   207  			return err
   208  		}
   209  		if exists != 0 {
   210  			resp.Errors = true
   211  			resp.TimeError = "Times clash with existing event"
   212  		}
   213  	}
   214  	if e.From == "" {
   215  		resp.Errors = true
   216  		resp.FromError = "From/Pickup location required"
   217  	}
   218  	if e.To == "" {
   219  		resp.Errors = true
   220  		resp.ToError = "To/Dropoff location required"
   221  	}
   222  	if !resp.Errors {
   223  		c.mu.Lock()
   224  		defer c.mu.Unlock()
   225  		fromID, err := c.addressID(e.From, false)
   226  		if err != nil {
   227  			return err
   228  		}
   229  		toID, err := c.addressID(e.To, true)
   230  		if err != nil {
   231  			return err
   232  		}
   233  		t := now()
   234  		if e.ID == 0 {
   235  			var note string
   236  			_, err = c.statements[GetClientNote].Exec(e.ClientID)
   237  			if err == nil {
   238  				r, er := c.statements[CreateEvent].Exec(e.DriverID, e.ClientID, e.Start, e.End, fromID, toID, e.Other, note, e.ClientReference, e.Booker, e.FlightTime, e.Profile, t, t)
   239  				if er == nil {
   240  					resp.ID, er = r.LastInsertId()
   241  				}
   242  				err = er
   243  			}
   244  		} else {
   245  			resp.ID = e.ID
   246  			_, err = c.statements[UpdateEvent].Exec(e.DriverID, e.ClientID, e.Start, e.End, fromID, toID, e.Other, e.ClientReference, e.Booker, e.FlightTime, e.Profile, t, e.ID)
   247  		}
   248  		if err != nil {
   249  			return err
   250  		}
   251  	}
   252  	return nil
   253  }
   254  
   255  func (c *Calls) addressID(address string, fromTo bool) (int64, error) {
   256  	var readAddress, createAddress int
   257  	if fromTo {
   258  		readAddress = ReadToAddress
   259  		createAddress = CreateToAddress
   260  	} else {
   261  		readAddress = ReadFromAddress
   262  		createAddress = CreateFromAddress
   263  	}
   264  	address = strings.TrimSpace(address)
   265  	var id int64
   266  	err := c.statements[readAddress].QueryRow(address).Scan(&id)
   267  	if err != nil && err != sql.ErrNoRows {
   268  		return 0, err
   269  	}
   270  	if id == 0 {
   271  		r, err := c.statements[createAddress].Exec(address)
   272  		if err != nil {
   273  			return 0, err
   274  		}
   275  		return r.LastInsertId()
   276  	}
   277  	return id, nil
   278  }
   279  
   280  func (c *Calls) RemoveDriver(id int64, _ *struct{}) error {
   281  	c.mu.Lock()
   282  	defer c.mu.Unlock()
   283  	_, err := c.statements[DeleteDriver].Exec(id)
   284  	if err != nil {
   285  		return err
   286  	}
   287  	_, err = c.statements[DeleteDriverEvents].Exec(id)
   288  	return err
   289  }
   290  
   291  func (c *Calls) RemoveClient(id int64, _ *struct{}) error {
   292  	c.mu.Lock()
   293  	defer c.mu.Unlock()
   294  	_, err := c.statements[DeleteClient].Exec(id)
   295  	if err != nil {
   296  		return err
   297  	}
   298  	_, err = c.statements[DeleteClientEvents].Exec(now(), id)
   299  	return err
   300  }
   301  
   302  func (c *Calls) RemoveCompany(id int64, _ *struct{}) error {
   303  	c.mu.Lock()
   304  	defer c.mu.Unlock()
   305  	_, err := c.statements[DeleteCompany].Exec(id)
   306  	if err != nil {
   307  		return err
   308  	}
   309  	_, err = c.statements[DeleteCompanyClients].Exec(id)
   310  	if err != nil {
   311  		return err
   312  	}
   313  	_, err = c.statements[DeleteCompanyEvents].Exec(now(), id)
   314  	return err
   315  }
   316  
   317  func (c *Calls) RemoveEvent(id int64, _ *struct{}) error {
   318  	_, err := c.statements[DeleteEvent].Exec(now(), id)
   319  	return err
   320  }
   321